From 8d0aa39920bf004efa957a09cb8a9bd1ee624f23 Mon Sep 17 00:00:00 2001
From: Rhys Arkins <rhys@arkins.net>
Date: Sun, 24 Nov 2019 08:43:24 +0100
Subject: [PATCH] refactor(eslint):
'@typescript-eslint/explicit-function-return-type' improvements
---
lib/config/.eslintrc.js | 5 +++
lib/config/cli.ts | 8 ++--
lib/config/definitions.ts | 2 +-
lib/config/env.ts | 8 ++--
lib/config/presets.ts | 2 +-
lib/logger/__mocks__/index.ts | 2 +-
lib/logger/index.ts | 4 +-
lib/logger/pretty-stdout.ts | 6 +--
lib/platform/index.ts | 4 +-
lib/platform/utils/read-only-issue-body.ts | 2 +-
lib/renovate.ts | 2 +-
lib/util/.eslintrc.js | 5 +++
lib/util/emoji.ts | 2 +-
lib/util/got/stats.ts | 4 +-
lib/util/host-rules.ts | 36 +++++++++---------
lib/util/regex.ts | 2 +-
lib/util/sanitize.ts | 6 +--
lib/versioning/.eslintrc.js | 5 +++
lib/versioning/cargo/index.ts | 25 ++++++------
lib/versioning/composer/index.ts | 34 ++++++++---------
lib/versioning/docker/index.ts | 8 ++--
lib/versioning/hashicorp/index.ts | 15 ++++----
lib/versioning/hex/index.ts | 17 +++++----
lib/versioning/ivy/index.ts | 4 +-
lib/versioning/loose/generic.ts | 34 +++++++++--------
lib/versioning/loose/index.ts | 4 +-
lib/versioning/maven/compare.ts | 38 +++++++++----------
lib/versioning/maven/index.ts | 8 ++--
lib/versioning/node/index.ts | 2 +-
lib/versioning/npm/index.ts | 6 +--
lib/versioning/npm/range.ts | 2 +-
lib/versioning/nuget/index.ts | 6 +--
lib/versioning/pep440/index.ts | 10 ++---
lib/versioning/pep440/range.ts | 4 +-
lib/versioning/poetry/index.ts | 25 ++++++------
lib/versioning/regex/index.ts | 2 +-
lib/versioning/ruby/index.ts | 31 +++++++--------
lib/versioning/ruby/operator.ts | 5 ++-
lib/versioning/ruby/range.ts | 2 +-
lib/versioning/ruby/strategies/bump.ts | 2 +-
lib/versioning/ruby/strategies/pin.ts | 2 +-
lib/versioning/ruby/strategies/replace.ts | 2 +-
lib/versioning/ruby/version.ts | 12 +++---
lib/versioning/semver/index.ts | 4 +-
lib/versioning/swift/index.ts | 12 +++---
lib/versioning/swift/range.ts | 4 +-
lib/workers/branch/schedule.ts | 2 +-
lib/workers/branch/status-checks.ts | 4 +-
lib/workers/global/limits.ts | 8 ++--
.../repository/onboarding/branch/check.ts | 8 +++-
.../repository/process/lookup/index.ts | 2 +-
lib/workers/repository/updates/branchify.ts | 5 ++-
lib/workers/repository/updates/flatten.ts | 2 +-
lib/workers/repository/updates/generate.ts | 8 +++-
test/.eslintrc.js | 1 +
test/static-files.spec.ts | 4 +-
test/website-docs.spec.ts | 6 ++-
57 files changed, 257 insertions(+), 218 deletions(-)
create mode 100644 lib/config/.eslintrc.js
create mode 100644 lib/util/.eslintrc.js
create mode 100644 lib/versioning/.eslintrc.js
diff --git a/lib/config/.eslintrc.js b/lib/config/.eslintrc.js
new file mode 100644
index 0000000000..8bcc65cc06
--- /dev/null
+++ b/lib/config/.eslintrc.js
@@ -0,0 +1,5 @@
+module.exports = {
+ rules: {
+ '@typescript-eslint/explicit-function-return-type': 2,
+ },
+};
diff --git a/lib/config/cli.ts b/lib/config/cli.ts
index 7666b70f7b..bd5153ce3d 100644
--- a/lib/config/cli.ts
+++ b/lib/config/cli.ts
@@ -33,7 +33,7 @@ export function getConfig(input: string[]): RenovateCliConfig {
const config: RenovateCliConfig = {};
const coersions = {
- boolean: (val: string) => {
+ boolean: (val: string): boolean => {
if (val === 'true' || val === '') return true;
if (val === 'false') return false;
throw new Error(
@@ -42,7 +42,7 @@ export function getConfig(input: string[]): RenovateCliConfig {
"'"
);
},
- array: (val: string) => {
+ array: (val: string): string[] => {
if (val === '') {
return [];
}
@@ -52,7 +52,7 @@ export function getConfig(input: string[]): RenovateCliConfig {
return val.split(',').map(el => el.trim());
}
},
- object: (val: string) => {
+ object: (val: string): any => {
if (val === '') {
return {};
}
@@ -62,7 +62,7 @@ export function getConfig(input: string[]): RenovateCliConfig {
throw new Error("Invalid JSON value: '" + val + "'");
}
},
- string: (val: string) => val,
+ string: (val: string): string => val,
integer: parseInt,
};
diff --git a/lib/config/definitions.ts b/lib/config/definitions.ts
index 15886aa93a..ddb37f960a 100644
--- a/lib/config/definitions.ts
+++ b/lib/config/definitions.ts
@@ -2041,6 +2041,6 @@ const options: RenovateOptions[] = [
},
];
-export function getOptions() {
+export function getOptions(): any {
return options;
}
diff --git a/lib/config/env.ts b/lib/config/env.ts
index e6250321e7..3000b62904 100644
--- a/lib/config/env.ts
+++ b/lib/config/env.ts
@@ -18,10 +18,10 @@ export function getConfig(env: NodeJS.ProcessEnv): RenovateConfig {
const config: RenovateConfig = { hostRules: [] };
const coersions = {
- boolean: (val: string) => val === 'true',
- array: (val: string) => val.split(',').map(el => el.trim()),
- string: (val: string) => val.replace(/\\n/g, '\n'),
- object: (val: string) => JSON.parse(val),
+ boolean: (val: string): boolean => val === 'true',
+ array: (val: string): string[] => val.split(',').map(el => el.trim()),
+ string: (val: string): string => val.replace(/\\n/g, '\n'),
+ object: (val: string): any => JSON.parse(val),
integer: parseInt,
};
diff --git a/lib/config/presets.ts b/lib/config/presets.ts
index 48062a6410..d2672521b6 100644
--- a/lib/config/presets.ts
+++ b/lib/config/presets.ts
@@ -18,7 +18,7 @@ const datasources = {
export function replaceArgs(
obj: string | string[] | object | object[],
argMapping: Record<string, any>
-) {
+): any {
if (is.string(obj)) {
let returnStr = obj;
for (const [arg, argVal] of Object.entries(argMapping)) {
diff --git a/lib/logger/__mocks__/index.ts b/lib/logger/__mocks__/index.ts
index b303a70ad2..36b7185649 100644
--- a/lib/logger/__mocks__/index.ts
+++ b/lib/logger/__mocks__/index.ts
@@ -16,6 +16,6 @@ loggerLevels.forEach(k => {
export const setMeta = jest.fn();
export const levels = jest.fn();
export const addStream = jest.fn();
-export const getErrors = () => [];
+export const getErrors = (): any[] => [];
export { logger };
diff --git a/lib/logger/index.ts b/lib/logger/index.ts
index 9b838a1924..ec499ade79 100644
--- a/lib/logger/index.ts
+++ b/lib/logger/index.ts
@@ -98,7 +98,7 @@ loggerLevels.forEach(loggerLevel => {
});
// setMeta overrides existing meta
-export function setMeta(obj: any) {
+export function setMeta(obj: any): void {
meta = { ...obj };
}
@@ -112,6 +112,6 @@ export function levels(name: string, level: bunyan.LogLevel): void {
bunyanLogger.levels(name, level);
}
-export function getErrors() {
+export function getErrors(): any {
return errors.getErrors();
}
diff --git a/lib/logger/pretty-stdout.ts b/lib/logger/pretty-stdout.ts
index 318a528d0b..f4becca043 100644
--- a/lib/logger/pretty-stdout.ts
+++ b/lib/logger/pretty-stdout.ts
@@ -35,12 +35,12 @@ const levels: Record<number, string> = {
60: chalk.bgRed('FATAL'),
};
-export function indent(str: string, leading = false) {
+export function indent(str: string, leading = false): string {
const prefix = leading ? ' ' : '';
return prefix + str.split(/\r?\n/).join('\n ');
}
-export function getMeta(rec: BunyanRecord) {
+export function getMeta(rec: BunyanRecord): string {
if (!rec) {
return '';
}
@@ -56,7 +56,7 @@ export function getMeta(rec: BunyanRecord) {
return chalk.gray(res);
}
-export function getDetails(rec: BunyanRecord) {
+export function getDetails(rec: BunyanRecord): string {
if (!rec) {
return '';
}
diff --git a/lib/platform/index.ts b/lib/platform/index.ts
index 60ccc5d709..7d335490f0 100644
--- a/lib/platform/index.ts
+++ b/lib/platform/index.ts
@@ -36,7 +36,9 @@ export async function setPlatformApi(name: string): Promise<void> {
_platform = await import('./' + name);
}
-export async function initPlatform(config: RenovateConfig) {
+export async function initPlatform(
+ config: RenovateConfig
+): Promise<RenovateConfig> {
await setPlatformApi(config.platform);
// TODO: types
const platformInfo = await platform.initPlatform(config);
diff --git a/lib/platform/utils/read-only-issue-body.ts b/lib/platform/utils/read-only-issue-body.ts
index 4f9959b628..56813a3415 100644
--- a/lib/platform/utils/read-only-issue-body.ts
+++ b/lib/platform/utils/read-only-issue-body.ts
@@ -1,4 +1,4 @@
-export function readOnlyIssueBody(body: string) {
+export function readOnlyIssueBody(body: string): string {
return body
.replace(' only once you click their checkbox below', '')
.replace(' unless you click a checkbox below', '')
diff --git a/lib/renovate.ts b/lib/renovate.ts
index e44bbd478f..cd4a703202 100644
--- a/lib/renovate.ts
+++ b/lib/renovate.ts
@@ -5,6 +5,6 @@ import * as globalWorker from './workers/global';
proxy.bootstrap();
-(async () => {
+(async (): Promise<void> => {
process.exitCode = await globalWorker.start();
})();
diff --git a/lib/util/.eslintrc.js b/lib/util/.eslintrc.js
new file mode 100644
index 0000000000..8bcc65cc06
--- /dev/null
+++ b/lib/util/.eslintrc.js
@@ -0,0 +1,5 @@
+module.exports = {
+ rules: {
+ '@typescript-eslint/explicit-function-return-type': 2,
+ },
+};
diff --git a/lib/util/emoji.ts b/lib/util/emoji.ts
index d27b3baf45..98bb118575 100644
--- a/lib/util/emoji.ts
+++ b/lib/util/emoji.ts
@@ -3,7 +3,7 @@ import { RenovateConfig } from '../config';
let unicodeEmoji = false;
-export function setEmojiConfig(_config: RenovateConfig) {
+export function setEmojiConfig(_config: RenovateConfig): void {
unicodeEmoji = _config.unicodeEmoji;
}
diff --git a/lib/util/got/stats.ts b/lib/util/got/stats.ts
index 9e4826173b..2217781fb2 100644
--- a/lib/util/got/stats.ts
+++ b/lib/util/got/stats.ts
@@ -11,12 +11,12 @@ interface HostStats {
let stats: Record<string, number[]> = {};
// istanbul ignore next
-export const resetStats = () => {
+export const resetStats = (): void => {
stats = {};
};
// istanbul ignore next
-export const printStats = () => {
+export const printStats = (): void => {
logger.trace({ stats }, 'Host transfer stats (milliseconds)');
const hostStats: Record<string, HostStats> = {};
for (const [hostname, entries] of Object.entries(stats)) {
diff --git a/lib/util/host-rules.ts b/lib/util/host-rules.ts
index 09f02a8a1f..451f5f8f20 100644
--- a/lib/util/host-rules.ts
+++ b/lib/util/host-rules.ts
@@ -18,7 +18,7 @@ export interface HostRule {
let hostRules: HostRule[] = [];
-export function add(params: HostRule) {
+export function add(params: HostRule): void {
if (params.domainName && params.hostName) {
throw new Error('hostRules cannot contain both a domainName and hostName');
}
@@ -47,35 +47,35 @@ export interface HostRuleSearch {
url?: string;
}
-function isEmptyRule(rule: HostRule) {
+function isEmptyRule(rule: HostRule): boolean {
return !rule.hostType && !rule.domainName && !rule.hostName && !rule.baseUrl;
}
-function isHostTypeRule(rule: HostRule) {
+function isHostTypeRule(rule: HostRule): boolean {
return rule.hostType && !rule.domainName && !rule.hostName && !rule.baseUrl;
}
-function isDomainNameRule(rule: HostRule) {
- return !rule.hostType && rule.domainName;
+function isDomainNameRule(rule: HostRule): boolean {
+ return !rule.hostType && !!rule.domainName;
}
-function isHostNameRule(rule: HostRule) {
- return !rule.hostType && rule.hostName;
+function isHostNameRule(rule: HostRule): boolean {
+ return !rule.hostType && !!rule.hostName;
}
-function isBaseUrlRule(rule: HostRule) {
- return !rule.hostType && rule.baseUrl;
+function isBaseUrlRule(rule: HostRule): boolean {
+ return !rule.hostType && !!rule.baseUrl;
}
-function isMultiRule(rule: HostRule) {
- return rule.hostType && (rule.domainName || rule.hostName || rule.baseUrl);
+function isMultiRule(rule: HostRule): boolean {
+ return rule.hostType && !!(rule.domainName || rule.hostName || rule.baseUrl);
}
-function matchesHostType(rule: HostRule, search: HostRuleSearch) {
+function matchesHostType(rule: HostRule, search: HostRuleSearch): boolean {
return rule.hostType === search.hostType;
}
-function matchesDomainName(rule: HostRule, search: HostRuleSearch) {
+function matchesDomainName(rule: HostRule, search: HostRuleSearch): boolean {
const hostname = search.url && URL.parse(search.url).hostname;
return (
search.url &&
@@ -85,7 +85,7 @@ function matchesDomainName(rule: HostRule, search: HostRuleSearch) {
);
}
-function matchesHostName(rule: HostRule, search: HostRuleSearch) {
+function matchesHostName(rule: HostRule, search: HostRuleSearch): boolean {
return (
search.url &&
rule.hostName &&
@@ -93,11 +93,11 @@ function matchesHostName(rule: HostRule, search: HostRuleSearch) {
);
}
-function matchesBaseUrl(rule: HostRule, search: HostRuleSearch) {
+function matchesBaseUrl(rule: HostRule, search: HostRuleSearch): boolean {
return search.url && rule.baseUrl && search.url.startsWith(rule.baseUrl);
}
-export function find(search: HostRuleSearch) {
+export function find(search: HostRuleSearch): HostRule {
if (!(search.hostType || search.url)) {
logger.warn({ search }, 'Invalid hostRules search');
return {};
@@ -153,7 +153,7 @@ export function find(search: HostRuleSearch) {
return res;
}
-export function hosts({ hostType }: { hostType: string }) {
+export function hosts({ hostType }: { hostType: string }): string[] {
return hostRules
.filter(rule => rule.hostType === hostType)
.map(rule => {
@@ -164,7 +164,7 @@ export function hosts({ hostType }: { hostType: string }) {
.filter(Boolean);
}
-export function clear() {
+export function clear(): void {
hostRules = [];
sanitize.clear();
}
diff --git a/lib/util/regex.ts b/lib/util/regex.ts
index 3094b008a1..41dfce98f1 100644
--- a/lib/util/regex.ts
+++ b/lib/util/regex.ts
@@ -14,7 +14,7 @@ try {
RegEx = RegExp;
}
-export function regEx(pattern: string, flags?: string) {
+export function regEx(pattern: string, flags?: string): RegExp {
try {
return new RegEx(pattern, flags);
} catch (err) {
diff --git a/lib/util/sanitize.ts b/lib/util/sanitize.ts
index 98d6b737c1..c132400979 100644
--- a/lib/util/sanitize.ts
+++ b/lib/util/sanitize.ts
@@ -1,6 +1,6 @@
const secrets = new Set<string>();
-export function sanitize(input: string) {
+export function sanitize(input: string): string {
if (!input) return input;
let output: string = input;
secrets.forEach(secret => {
@@ -11,10 +11,10 @@ export function sanitize(input: string) {
return output;
}
-export function add(secret: string) {
+export function add(secret: string): void {
secrets.add(secret);
}
-export function clear() {
+export function clear(): void {
secrets.clear();
}
diff --git a/lib/versioning/.eslintrc.js b/lib/versioning/.eslintrc.js
new file mode 100644
index 0000000000..8bcc65cc06
--- /dev/null
+++ b/lib/versioning/.eslintrc.js
@@ -0,0 +1,5 @@
+module.exports = {
+ rules: {
+ '@typescript-eslint/explicit-function-return-type': 2,
+ },
+};
diff --git a/lib/versioning/cargo/index.ts b/lib/versioning/cargo/index.ts
index a33f78be12..50847c56b2 100644
--- a/lib/versioning/cargo/index.ts
+++ b/lib/versioning/cargo/index.ts
@@ -1,9 +1,9 @@
import { api as npm } from '../npm';
import { VersioningApi, RangeStrategy } from '../common';
-const isVersion = (input: string) => npm.isVersion(input);
+const isVersion = (input: string): string | boolean => npm.isVersion(input);
-function convertToCaret(item: string) {
+function convertToCaret(item: string): string {
// In Cargo, "1.2.3" doesn't mean exactly 1.2.3, it means >= 1.2.3 < 2.0.0
if (isVersion(item)) {
// NOTE: Partial versions like '1.2' don't get converted to '^1.2'
@@ -14,17 +14,17 @@ function convertToCaret(item: string) {
return item.trim();
}
-function cargo2npm(input: string) {
+function cargo2npm(input: string): string {
let versions = input.split(',');
versions = versions.map(convertToCaret);
return versions.join(' ');
}
-function notEmpty(s: string) {
+function notEmpty(s: string): boolean {
return s !== '';
}
-function npm2cargo(input: string) {
+function npm2cargo(input: string): string {
// Note: this doesn't remove the ^
const res = input
.split(' ')
@@ -40,21 +40,22 @@ function npm2cargo(input: string) {
return res.join(', ');
}
-const isLessThanRange = (version: string, range: string) =>
+const isLessThanRange = (version: string, range: string): boolean =>
npm.isLessThanRange(version, cargo2npm(range));
-export const isValid = (input: string) => npm.isValid(cargo2npm(input));
+export const isValid = (input: string): string | boolean =>
+ npm.isValid(cargo2npm(input));
-const matches = (version: string, range: string) =>
+const matches = (version: string, range: string): boolean =>
npm.matches(version, cargo2npm(range));
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
npm.maxSatisfyingVersion(versions, cargo2npm(range));
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
npm.minSatisfyingVersion(versions, cargo2npm(range));
-const isSingleVersion = (constraint: string) =>
+const isSingleVersion = (constraint: string): string | boolean =>
constraint.trim().startsWith('=') &&
isVersion(
constraint
@@ -68,7 +69,7 @@ function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
if (rangeStrategy === 'pin' || isSingleVersion(currentValue)) {
let res = '=';
if (currentValue.startsWith('= ')) {
diff --git a/lib/versioning/composer/index.ts b/lib/versioning/composer/index.ts
index bdbb52de71..c5880f4a91 100644
--- a/lib/versioning/composer/index.ts
+++ b/lib/versioning/composer/index.ts
@@ -3,7 +3,7 @@ import { logger } from '../../logger';
import { api as npm } from '../npm';
import { VersioningApi, RangeStrategy } from '../common';
-function padZeroes(input: string) {
+function padZeroes(input: string): string {
const sections = input.split('.');
while (sections.length < 3) {
sections.push('0');
@@ -11,7 +11,7 @@ function padZeroes(input: string) {
return sections.join('.');
}
-function composer2npm(input: string) {
+function composer2npm(input: string): string {
if (npm.isVersion(input)) {
return input;
}
@@ -26,43 +26,43 @@ function composer2npm(input: string) {
return output;
}
-const equals = (a: string, b: string) =>
+const equals = (a: string, b: string): boolean =>
npm.equals(composer2npm(a), composer2npm(b));
-const getMajor = (version: string) =>
+const getMajor = (version: string): number =>
npm.getMajor(coerce(composer2npm(version)));
-const getMinor = (version: string) =>
+const getMinor = (version: string): number =>
npm.getMinor(coerce(composer2npm(version)));
-const getPatch = (version: string) =>
+const getPatch = (version: string): number =>
npm.getPatch(coerce(composer2npm(version)));
-const isGreaterThan = (a: string, b: string) =>
+const isGreaterThan = (a: string, b: string): boolean =>
npm.isGreaterThan(composer2npm(a), composer2npm(b));
-const isLessThanRange = (version: string, range: string) =>
+const isLessThanRange = (version: string, range: string): boolean =>
npm.isLessThanRange(composer2npm(version), composer2npm(range));
-const isSingleVersion = (input: string) =>
+const isSingleVersion = (input: string): string | boolean =>
input && npm.isSingleVersion(composer2npm(input));
-const isStable = (version: string) =>
+const isStable = (version: string): boolean =>
version && npm.isStable(composer2npm(version));
-export const isValid = (input: string) =>
+export const isValid = (input: string): string | boolean =>
input && npm.isValid(composer2npm(input));
-export const isVersion = (input: string) =>
+export const isVersion = (input: string): string | boolean =>
input && npm.isVersion(composer2npm(input));
-const matches = (version: string, range: string) =>
+const matches = (version: string, range: string): boolean =>
npm.matches(composer2npm(version), composer2npm(range));
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
npm.maxSatisfyingVersion(versions.map(composer2npm), composer2npm(range));
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
npm.minSatisfyingVersion(versions.map(composer2npm), composer2npm(range));
function getNewValue(
@@ -70,7 +70,7 @@ function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
if (rangeStrategy === 'pin') {
return toVersion;
}
@@ -138,7 +138,7 @@ function getNewValue(
return newValue;
}
-function sortVersions(a: string, b: string) {
+function sortVersions(a: string, b: string): number {
return npm.sortVersions(composer2npm(a), composer2npm(b));
}
diff --git a/lib/versioning/docker/index.ts b/lib/versioning/docker/index.ts
index 9f7f4ab4c1..00b6f64f08 100644
--- a/lib/versioning/docker/index.ts
+++ b/lib/versioning/docker/index.ts
@@ -1,7 +1,7 @@
import * as generic from '../loose/generic';
import { VersioningApi } from '../common';
-function parse(version: string) {
+function parse(version: string): any {
const versionPieces = version.replace(/^v/, '').split('-');
const prefix = versionPieces.shift();
const suffix = versionPieces.join('-');
@@ -12,12 +12,12 @@ function parse(version: string) {
return { release, suffix };
}
-function valueToVersion(value: string) {
+function valueToVersion(value: string): string {
// Remove any suffix after '-', e.g. '-alpine'
return value ? value.split('-')[0] : value;
}
-function compare(version1: string, vervion2: string) {
+function compare(version1: string, vervion2: string): number {
const parsed1 = parse(version1);
const parsed2 = parse(vervion2);
// istanbul ignore if
@@ -43,7 +43,7 @@ function compare(version1: string, vervion2: string) {
return parsed2.suffix.localeCompare(parsed1.suffix);
}
-function isCompatible(version: string, range: string) {
+function isCompatible(version: string, range: string): boolean {
const parsed1 = parse(version);
const parsed2 = parse(range);
return (
diff --git a/lib/versioning/hashicorp/index.ts b/lib/versioning/hashicorp/index.ts
index 5ed2786188..f29b5ee4b0 100644
--- a/lib/versioning/hashicorp/index.ts
+++ b/lib/versioning/hashicorp/index.ts
@@ -1,23 +1,24 @@
import { api as npm } from '../npm';
import { VersioningApi, RangeStrategy } from '../common';
-function hashicorp2npm(input: string) {
+function hashicorp2npm(input: string): string {
// The only case incompatible with semver is a "short" ~>, e.g. ~> 1.2
return input.replace(/~>(\s*\d+\.\d+$)/, '^$1').replace(',', '');
}
-const isLessThanRange = (version: string, range: string) =>
+const isLessThanRange = (version: string, range: string): boolean =>
npm.isLessThanRange(hashicorp2npm(version), hashicorp2npm(range));
-export const isValid = (input: string) => npm.isValid(hashicorp2npm(input));
+export const isValid = (input: string): string | boolean =>
+ npm.isValid(hashicorp2npm(input));
-const matches = (version: string, range: string) =>
+const matches = (version: string, range: string): boolean =>
npm.matches(hashicorp2npm(version), hashicorp2npm(range));
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
npm.maxSatisfyingVersion(versions.map(hashicorp2npm), hashicorp2npm(range));
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
npm.minSatisfyingVersion(versions.map(hashicorp2npm), hashicorp2npm(range));
function getNewValue(
@@ -25,7 +26,7 @@ function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
// handle specia. ~> 1.2 case
if (currentValue.match(/(~>\s*)\d+\.\d+$/)) {
return currentValue.replace(
diff --git a/lib/versioning/hex/index.ts b/lib/versioning/hex/index.ts
index a6e396fb93..4f7b9a20f9 100644
--- a/lib/versioning/hex/index.ts
+++ b/lib/versioning/hex/index.ts
@@ -1,7 +1,7 @@
import { api as npm } from '../npm';
import { VersioningApi, RangeStrategy } from '../common';
-function hex2npm(input: string) {
+function hex2npm(input: string): string {
return input
.replace(/~>\s*(\d+\.\d+)$/, '^$1')
.replace(/~>\s*(\d+\.\d+\.\d+)/, '~$1')
@@ -10,7 +10,7 @@ function hex2npm(input: string) {
.replace(/!=\s*(\d+\.\d+(\.\d+.*)?)/, '>$1 <$1');
}
-function npm2hex(input: string) {
+function npm2hex(input: string): string {
const res = input
.split(' ')
.map(str => str.trim())
@@ -31,18 +31,19 @@ function npm2hex(input: string) {
return output;
}
-const isLessThanRange = (version: string, range: string) =>
+const isLessThanRange = (version: string, range: string): boolean =>
npm.isLessThanRange(hex2npm(version), hex2npm(range));
-const isValid = (input: string) => npm.isValid(hex2npm(input));
+const isValid = (input: string): string | boolean =>
+ npm.isValid(hex2npm(input));
-const matches = (version: string, range: string) =>
+const matches = (version: string, range: string): boolean =>
npm.matches(hex2npm(version), hex2npm(range));
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
npm.maxSatisfyingVersion(versions.map(hex2npm), hex2npm(range));
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
npm.minSatisfyingVersion(versions.map(hex2npm), hex2npm(range));
const getNewValue = (
@@ -50,7 +51,7 @@ const getNewValue = (
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) => {
+): string => {
let newSemver = npm.getNewValue(
hex2npm(currentValue),
rangeStrategy,
diff --git a/lib/versioning/ivy/index.ts b/lib/versioning/ivy/index.ts
index 68d516c882..7f273001e6 100644
--- a/lib/versioning/ivy/index.ts
+++ b/lib/versioning/ivy/index.ts
@@ -22,14 +22,14 @@ const {
sortVersions,
} = maven;
-function isVersion(str: string) {
+function isVersion(str: string): string | boolean {
if (!str) {
return false;
}
return isSingleVersion(str) || !!parseDynamicRevision(str);
}
-function matches(a: string, b: string) {
+function matches(a: string, b: string): boolean {
if (!a) return false;
if (!b) return false;
const dynamicRevision = parseDynamicRevision(b);
diff --git a/lib/versioning/loose/generic.ts b/lib/versioning/loose/generic.ts
index bec102da62..ce5c09d199 100644
--- a/lib/versioning/loose/generic.ts
+++ b/lib/versioning/loose/generic.ts
@@ -16,34 +16,38 @@ export interface VersionComparator {
// parse should return null if version not valid
// parse should return an object with property release, an array of version sections major.minor.patch
export const parser = (parse: VersionParser): Partial<VersioningApi> => {
- function isValid(version: string) {
+ function isValid(version: string): string {
if (!version) {
return null;
}
const parsed = parse(version);
return parsed ? version : null;
}
- function getSection(version: string, index: number) {
+ function getSection(version: string, index: number): number {
const parsed = parse(version);
return parsed && parsed.release.length > index
? parsed.release[index]
: null;
}
- function getMajor(version: string) {
+ function getMajor(version: string): number {
return getSection(version, 0);
}
- function getMinor(version: string) {
+ function getMinor(version: string): number {
return getSection(version, 1);
}
- function getPatch(version: string) {
+ function getPatch(version: string): number {
return getSection(version, 2);
}
+ function isStable(version: string): boolean {
+ return !!isValid(version);
+ }
+
return {
// validation
isCompatible: isValid,
isSingleVersion: isValid,
- isStable: v => !!isValid(v),
+ isStable,
isValid,
isVersion: isValid,
// digestion of version
@@ -58,22 +62,22 @@ export const parser = (parse: VersionParser): Partial<VersioningApi> => {
export const comparer = (
compare: VersionComparator
): Partial<VersioningApi> => {
- function equals(version: string, other: string) {
+ function equals(version: string, other: string): boolean {
return compare(version, other) === 0;
}
- function isGreaterThan(version: string, other: string) {
+ function isGreaterThan(version: string, other: string): boolean {
return compare(version, other) > 0;
}
- function isLessThanRange(version: string, range: string) {
+ function isLessThanRange(version: string, range: string): boolean {
return compare(version, range) < 0;
}
// we don't not have ranges, so versions has to be equal
- function maxSatisfyingVersion(versions: string[], range: string) {
+ function maxSatisfyingVersion(versions: string[], range: string): string {
return versions.find(v => equals(v, range)) || null;
}
- function minSatisfyingVersion(versions: string[], range: string) {
+ function minSatisfyingVersion(versions: string[], range: string): string {
return versions.find(v => equals(v, range)) || null;
}
function getNewValue(
@@ -81,10 +85,10 @@ export const comparer = (
_rangeStrategy: RangeStrategy,
_fromVersion: string,
toVersion: string
- ) {
+ ): string {
return toVersion;
}
- function sortVersions(version: string, other: string) {
+ function sortVersions(version: string, other: string): number {
return compare(version, other);
}
@@ -108,7 +112,7 @@ export const create = ({
}: {
parse: VersionParser;
compare: VersionComparator;
-}) => {
+}): any => {
let schema: VersioningApi = {} as any;
if (parse) {
schema = { ...schema, ...parser(parse) };
@@ -122,7 +126,7 @@ export const create = ({
export abstract class GenericVersioningApi<
T extends GenericVersion = GenericVersion
> implements VersioningApi {
- private _getSection(version: string, index: number) {
+ private _getSection(version: string, index: number): number {
const parsed = this._parse(version);
return parsed && parsed.release.length > index
? parsed.release[index]
diff --git a/lib/versioning/loose/index.ts b/lib/versioning/loose/index.ts
index 9c6f53985b..2f2cf8b0c9 100644
--- a/lib/versioning/loose/index.ts
+++ b/lib/versioning/loose/index.ts
@@ -3,7 +3,7 @@ import { VersioningApi } from '../common';
const pattern = /^v?(\d+(?:\.\d+)*)(.*)$/;
-function parse(version: string) {
+function parse(version: string): any {
const matches = pattern.exec(version);
if (!matches) {
return null;
@@ -16,7 +16,7 @@ function parse(version: string) {
return { release, suffix: suffix || '' };
}
-function compare(version1: string, vervion2: string) {
+function compare(version1: string, vervion2: string): number {
const parsed1 = parse(version1);
const parsed2 = parse(vervion2);
// istanbul ignore if
diff --git a/lib/versioning/maven/compare.ts b/lib/versioning/maven/compare.ts
index 32af458aa7..af22f91bda 100644
--- a/lib/versioning/maven/compare.ts
+++ b/lib/versioning/maven/compare.ts
@@ -23,7 +23,7 @@ export interface QualifierToken extends BaseToken {
export type Token = NumberToken | QualifierToken;
-function iterateChars(str: string, cb: (p: string, n: string) => void) {
+function iterateChars(str: string, cb: (p: string, n: string) => void): void {
let prev = null;
let next = null;
for (let i = 0; i < str.length; i += 1) {
@@ -34,26 +34,26 @@ function iterateChars(str: string, cb: (p: string, n: string) => void) {
cb(prev, null);
}
-function isDigit(char: string) {
+function isDigit(char: string): boolean {
return /^\d$/.test(char);
}
-function isLetter(char: string) {
+function isLetter(char: string): boolean {
return /^[a-z]$/i.test(char);
}
-function isTransition(prevChar: string, nextChar: string) {
+function isTransition(prevChar: string, nextChar: string): boolean {
return (
(isDigit(prevChar) && isLetter(nextChar)) ||
(isLetter(prevChar) && isDigit(nextChar))
);
}
-function iterateTokens(versionStr: string, cb: (token: Token) => void) {
+function iterateTokens(versionStr: string, cb: (token: Token) => void): void {
let currentPrefix = PREFIX_HYPHEN;
let currentVal = '';
- function yieldToken(transition = false) {
+ function yieldToken(transition = false): void {
const val = currentVal || '0';
if (/^\d+$/.test(val)) {
cb({
@@ -93,7 +93,7 @@ function iterateTokens(versionStr: string, cb: (token: Token) => void) {
});
}
-function isNull(token: Token) {
+function isNull(token: Token): boolean {
const val = token.val;
return (
val === 0 ||
@@ -112,7 +112,7 @@ const zeroToken: NumberToken = {
isTransition: false,
};
-function tokenize(versionStr: string) {
+function tokenize(versionStr: string): Token[] {
let buf: Token[] = [];
let result: Token[] = [];
let leadingZero = true;
@@ -147,7 +147,7 @@ function nullFor(token: Token): Token {
};
}
-function commonOrder(token: Token) {
+function commonOrder(token: Token): number {
if (token.prefix === PREFIX_DOT && token.type === TYPE_QUALIFIER) {
return 0;
}
@@ -160,7 +160,7 @@ function commonOrder(token: Token) {
return 3;
}
-function qualifierOrder(token: Token) {
+function qualifierOrder(token: Token): number {
const val = token.val;
if (val === 'alpha' || (token.isTransition && val === 'a')) {
return 1;
@@ -192,7 +192,7 @@ function qualifierOrder(token: Token) {
return null;
}
-function qualifierCmp(left: Token, right: Token) {
+function qualifierCmp(left: Token, right: Token): number {
const leftOrder = qualifierOrder(left);
const rightOrder = qualifierOrder(right);
if (leftOrder && rightOrder) {
@@ -214,7 +214,7 @@ function qualifierCmp(left: Token, right: Token) {
return 1;
}
-function tokenCmp(left: Token, right: Token) {
+function tokenCmp(left: Token, right: Token): number {
if (left.prefix === right.prefix) {
if (left.type === TYPE_NUMBER && right.type === TYPE_NUMBER) {
if (left.val === right.val) {
@@ -245,7 +245,7 @@ function tokenCmp(left: Token, right: Token) {
return 1;
}
-function compare(left: string, right: string) {
+function compare(left: string, right: string): number {
const leftTokens = tokenize(left);
const rightTokens = tokenize(right);
const length = Math.max(leftTokens.length, rightTokens.length);
@@ -258,7 +258,7 @@ function compare(left: string, right: string) {
return 0;
}
-function isVersion(version: string) {
+function isVersion(version: string): boolean {
if (!version) return false;
if (!/^[a-z0-9.-]+$/i.test(version)) return false;
if (/^[.-]/.test(version)) return false;
@@ -270,7 +270,7 @@ function isVersion(version: string) {
const INCLUDING_POINT = 'INCLUDING_POINT';
const EXCLUDING_POINT = 'EXCLUDING_POINT';
-function parseRange(rangeStr: string) {
+function parseRange(rangeStr: string): any {
function emptyInterval(): Range {
return {
leftType: null,
@@ -367,7 +367,7 @@ function parseRange(rangeStr: string) {
);
}
-function isValid(str: string) {
+function isValid(str: string): boolean {
if (!str) {
return false;
}
@@ -386,7 +386,7 @@ export interface Range {
function rangeToStr(fullRange: Range[]): string | null {
if (fullRange === null) return null;
- const valToStr = (val: string) => (val === null ? '' : val);
+ const valToStr = (val: string): string => (val === null ? '' : val);
if (fullRange.length === 1) {
const { leftBracket, rightBracket, leftValue, rightValue } = fullRange[0];
@@ -417,7 +417,7 @@ function autoExtendMavenRange(
): string | null {
const range = parseRange(currentRepresentation);
if (!range) return currentRepresentation;
- const isPoint = (vals: Range[]) => {
+ const isPoint = (vals: Range[]): boolean => {
if (vals.length !== 1) return false;
const { leftType, leftValue, rightType, rightValue } = vals[0];
return (
@@ -454,7 +454,7 @@ function autoExtendMavenRange(
return rangeToStr(range);
}
-function isSubversion(majorVersion: string, minorVersion: string) {
+function isSubversion(majorVersion: string, minorVersion: string): boolean {
const majorTokens = tokenize(majorVersion);
const minorTokens = tokenize(minorVersion);
diff --git a/lib/versioning/maven/index.ts b/lib/versioning/maven/index.ts
index 645e220608..4cf72ac3ce 100644
--- a/lib/versioning/maven/index.ts
+++ b/lib/versioning/maven/index.ts
@@ -12,14 +12,14 @@ import {
} from './compare';
import { RangeStrategy, VersioningApi } from '../common';
-const equals = (a: string, b: string) => compare(a, b) === 0;
+const equals = (a: string, b: string): boolean => compare(a, b) === 0;
-function matches(a: string, b: string) {
+function matches(a: string, b: string): boolean {
if (!b) return false;
if (isVersion(b)) return equals(a, b);
const ranges = parseRange(b);
if (!ranges) return false;
- return ranges.reduce((result, range) => {
+ return ranges.reduce((result, range): any => {
if (result) return result;
const { leftType, leftValue, rightType, rightValue } = range;
@@ -83,7 +83,7 @@ const getPatch = (version: string): number | null => {
return null;
};
-const isGreaterThan = (a: string, b: string) => compare(a, b) === 1;
+const isGreaterThan = (a: string, b: string): boolean => compare(a, b) === 1;
const isStable = (version: string): boolean | null => {
if (isVersion(version)) {
diff --git a/lib/versioning/node/index.ts b/lib/versioning/node/index.ts
index 6a150c5bbf..dcde501adc 100644
--- a/lib/versioning/node/index.ts
+++ b/lib/versioning/node/index.ts
@@ -6,7 +6,7 @@ function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
const res = npm.getNewValue(
currentValue,
rangeStrategy,
diff --git a/lib/versioning/npm/index.ts b/lib/versioning/npm/index.ts
index 7f60432699..f78579d9f1 100644
--- a/lib/versioning/npm/index.ts
+++ b/lib/versioning/npm/index.ts
@@ -19,10 +19,10 @@ const {
} = semver;
// If this is left as an alias, inputs like "17.04.0" throw errors
-export const isValid = (input: string) => validRange(input);
-export const isVersion = (input: string) => valid(input);
+export const isValid = (input: string): string => validRange(input);
+export const isVersion = (input: string): string => valid(input);
-const isSingleVersion = (constraint: string) =>
+const isSingleVersion = (constraint: string): string =>
isVersion(constraint) ||
(constraint.startsWith('=') && isVersion(constraint.substring(1).trim()));
diff --git a/lib/versioning/npm/range.ts b/lib/versioning/npm/range.ts
index 92a3ef86bf..56019cec7e 100644
--- a/lib/versioning/npm/range.ts
+++ b/lib/versioning/npm/range.ts
@@ -16,7 +16,7 @@ export function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
if (rangeStrategy === 'pin' || isVersion(currentValue)) {
return toVersion;
}
diff --git a/lib/versioning/nuget/index.ts b/lib/versioning/nuget/index.ts
index dcf6969124..66a420fdd3 100644
--- a/lib/versioning/nuget/index.ts
+++ b/lib/versioning/nuget/index.ts
@@ -3,7 +3,7 @@ import { VersioningApi } from '../common';
const pattern = /^(\d+(?:\.\d+)*)(-[^+]+)?(\+.*)?$/;
-function parse(version: string) {
+function parse(version: string): any {
const matches = pattern.exec(version);
if (!matches) {
return null;
@@ -13,7 +13,7 @@ function parse(version: string) {
return { release, suffix: prereleasesuffix || '' };
}
-function compare(version1: string, vervion2: string) {
+function compare(version1: string, vervion2: string): number {
const parsed1 = parse(version1);
const parsed2 = parse(vervion2);
// istanbul ignore if
@@ -43,7 +43,7 @@ function compare(version1: string, vervion2: string) {
return suffixComparison;
}
-function isStable(version: string) {
+function isStable(version: string): boolean {
const parsed = parse(version);
return parsed && parsed.suffix === '';
}
diff --git a/lib/versioning/pep440/index.ts b/lib/versioning/pep440/index.ts
index 699fe4a48b..f0bf0b09f1 100644
--- a/lib/versioning/pep440/index.ts
+++ b/lib/versioning/pep440/index.ts
@@ -16,7 +16,7 @@ const {
eq: equals,
} = pep440;
-const isStable = (input: string) => {
+const isStable = (input: string): boolean => {
const version = explain(input);
if (!version) {
return false;
@@ -25,19 +25,19 @@ const isStable = (input: string) => {
};
// If this is left as an alias, inputs like "17.04.0" throw errors
-export const isValid = (input: string) => validRange(input);
+export const isValid = (input: string): string => validRange(input);
-const maxSatisfyingVersion = (versions: string[], range: string) => {
+const maxSatisfyingVersion = (versions: string[], range: string): string => {
const found = filter(versions, range).sort(sortVersions);
return found.length === 0 ? null : found[found.length - 1];
};
-const minSatisfyingVersion = (versions: string[], range: string) => {
+const minSatisfyingVersion = (versions: string[], range: string): string => {
const found = filter(versions, range).sort(sortVersions);
return found.length === 0 ? null : found[0];
};
-export const isSingleVersion = (constraint: string) =>
+export const isSingleVersion = (constraint: string): string =>
isVersion(constraint) ||
(constraint.startsWith('==') && isVersion(constraint.substring(2).trim()));
diff --git a/lib/versioning/pep440/range.ts b/lib/versioning/pep440/range.ts
index 3099407184..fafb81b38b 100644
--- a/lib/versioning/pep440/range.ts
+++ b/lib/versioning/pep440/range.ts
@@ -8,7 +8,7 @@ function getFutureVersion(
baseVersion: string,
toVersion: string,
step: number
-) {
+): string {
const toRelease: number[] = parseVersion(toVersion).release;
const baseRelease: number[] = parseVersion(baseVersion).release;
let found = false;
@@ -40,7 +40,7 @@ export function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
// easy pin
if (rangeStrategy === 'pin') {
return '==' + toVersion;
diff --git a/lib/versioning/poetry/index.ts b/lib/versioning/poetry/index.ts
index 6964d671d1..49ec562ff3 100644
--- a/lib/versioning/poetry/index.ts
+++ b/lib/versioning/poetry/index.ts
@@ -3,14 +3,14 @@ import { major, minor } from 'semver';
import { api as npm } from '../npm';
import { RangeStrategy, VersioningApi } from '../common';
-function notEmpty(s: string) {
+function notEmpty(s: string): boolean {
return s !== '';
}
// This function works like cargo2npm, but it doesn't
// add a '^', because poetry treats versions without operators as
// exact versions.
-function poetry2npm(input: string) {
+function poetry2npm(input: string): string {
const versions = input
.split(',')
.map(str => str.trim())
@@ -21,7 +21,7 @@ function poetry2npm(input: string) {
// NOTE: This function is copied from cargo versionsing code.
// Poetry uses commas (like in cargo) instead of spaces (like in npm)
// for AND operation.
-function npm2poetry(input: string) {
+function npm2poetry(input: string): string {
// Note: this doesn't remove the ^
const res = input
.split(' ')
@@ -37,22 +37,23 @@ function npm2poetry(input: string) {
return res.join(', ');
}
-const isLessThanRange = (version: string, range: string) =>
+const isLessThanRange = (version: string, range: string): boolean =>
npm.isLessThanRange(version, poetry2npm(range));
-export const isValid = (input: string) => npm.isValid(poetry2npm(input));
+export const isValid = (input: string): string | boolean =>
+ npm.isValid(poetry2npm(input));
-const isVersion = (input: string) => npm.isVersion(input);
-const matches = (version: string, range: string) =>
+const isVersion = (input: string): string | boolean => npm.isVersion(input);
+const matches = (version: string, range: string): boolean =>
npm.matches(version, poetry2npm(range));
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
npm.maxSatisfyingVersion(versions, poetry2npm(range));
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
npm.minSatisfyingVersion(versions, poetry2npm(range));
-const isSingleVersion = (constraint: string) =>
+const isSingleVersion = (constraint: string): string | boolean =>
(constraint.trim().startsWith('=') &&
isVersion(
constraint
@@ -66,7 +67,7 @@ function handleShort(
operator: string,
currentValue: string,
toVersion: string
-) {
+): string {
const toVersionMajor = major(toVersion);
const toVersionMinor = minor(toVersion);
const split = currentValue.split('.');
@@ -86,7 +87,7 @@ function getNewValue(
rangeStrategy: RangeStrategy,
fromVersion: string,
toVersion: string
-) {
+): string {
if (rangeStrategy === 'replace') {
const npmCurrentValue = poetry2npm(currentValue);
const parsedRange = parseRange(npmCurrentValue);
diff --git a/lib/versioning/regex/index.ts b/lib/versioning/regex/index.ts
index 94395785f4..a841467df5 100644
--- a/lib/versioning/regex/index.ts
+++ b/lib/versioning/regex/index.ts
@@ -113,7 +113,7 @@ export class RegExpVersioningApi extends GenericVersioningApi<RegExpVersion> {
);
}
- matches(version: string, range: string) {
+ matches(version: string, range: string): boolean {
return satisfies(
asSemver(this._parse(version)),
asSemver(this._parse(range))
diff --git a/lib/versioning/ruby/index.ts b/lib/versioning/ruby/index.ts
index 01c230b26b..8389ef7efa 100644
--- a/lib/versioning/ruby/index.ts
+++ b/lib/versioning/ruby/index.ts
@@ -13,17 +13,18 @@ import { parse as parseRange, ltr } from './range';
import { isSingleOperator, isValidOperator } from './operator';
import { pin, bump, replace } from './strategies';
-const equals = (left: string, right: string) => eq(left, right);
+const equals = (left: string, right: string): boolean => eq(left, right);
-const getMajor = (version: string) => parseVersion(version).major;
-const getMinor = (version: string) => parseVersion(version).minor;
-const getPatch = (version: string) => parseVersion(version).patch;
+const getMajor = (version: string): number => parseVersion(version).major;
+const getMinor = (version: string): number => parseVersion(version).minor;
+const getPatch = (version: string): number => parseVersion(version).patch;
-export const isVersion = (version: string) => !!valid(version);
-const isGreaterThan = (left: string, right: string) => gt(left, right);
-const isLessThanRange = (version: string, range: string) => ltr(version, range);
+export const isVersion = (version: string): boolean => !!valid(version);
+const isGreaterThan = (left: string, right: string): boolean => gt(left, right);
+const isLessThanRange = (version: string, range: string): boolean =>
+ ltr(version, range);
-const isSingleVersion = (range: string) => {
+const isSingleVersion = (range: string): boolean => {
const { version, operator } = parseRange(range);
return operator
@@ -31,10 +32,10 @@ const isSingleVersion = (range: string) => {
: isVersion(version);
};
-const isStable = (version: string) =>
+const isStable = (version: string): boolean =>
parseVersion(version).prerelease ? false : isVersion(version);
-export const isValid = (input: string) =>
+export const isValid = (input: string): boolean =>
input
.split(',')
.map(piece => piece.trim())
@@ -46,11 +47,11 @@ export const isValid = (input: string) =>
: isVersion(version);
});
-export const matches = (version: string, range: string) =>
+export const matches = (version: string, range: string): boolean =>
satisfies(version, range);
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
maxSatisfying(versions, range);
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
minSatisfying(versions, range);
const getNewValue = (
@@ -58,7 +59,7 @@ const getNewValue = (
rangeStrategy: RangeStrategy,
_fromVersion: string,
toVersion: string
-) => {
+): string => {
switch (rangeStrategy) {
case 'pin':
return pin({ to: toVersion });
@@ -73,7 +74,7 @@ const getNewValue = (
}
};
-export const sortVersions = (left: string, right: string) =>
+export const sortVersions = (left: string, right: string): number =>
gt(left, right) ? 1 : -1;
export const api: VersioningApi = {
diff --git a/lib/versioning/ruby/operator.ts b/lib/versioning/ruby/operator.ts
index 05e32a35e5..7b3b5def09 100644
--- a/lib/versioning/ruby/operator.ts
+++ b/lib/versioning/ruby/operator.ts
@@ -11,8 +11,9 @@ const PGTE = '~>';
const SINGLE = [EQUAL];
const ALL = [EQUAL, NOT_EQUAL, GT, LT, GTE, LTE, PGTE];
-const isValidOperator = (operator: string) => ALL.includes(operator);
-const isSingleOperator = (operator: string) => SINGLE.includes(operator);
+const isValidOperator = (operator: string): boolean => ALL.includes(operator);
+const isSingleOperator = (operator: string): boolean =>
+ SINGLE.includes(operator);
export {
EQUAL,
diff --git a/lib/versioning/ruby/range.ts b/lib/versioning/ruby/range.ts
index e2f161f0e6..3aaa5e98b0 100644
--- a/lib/versioning/ruby/range.ts
+++ b/lib/versioning/ruby/range.ts
@@ -27,7 +27,7 @@ interface GemVersion {
}
type GemRequirement = [string, GemVersion];
-const ltr = (version: string, range: string) => {
+const ltr = (version: string, range: string): boolean => {
const gemVersion: GemVersion = create(version);
const requirements: GemRequirement[] = range.split(',').map(_parse);
diff --git a/lib/versioning/ruby/strategies/bump.ts b/lib/versioning/ruby/strategies/bump.ts
index 723adedda7..350127831a 100644
--- a/lib/versioning/ruby/strategies/bump.ts
+++ b/lib/versioning/ruby/strategies/bump.ts
@@ -4,7 +4,7 @@ import { EQUAL, NOT_EQUAL, GT, LT, GTE, LTE, PGTE } from '../operator';
import { floor, increment, decrement } from '../version';
import { parse as parseRange } from '../range';
-export default ({ range, to }: { range: string; to: string }) => {
+export default ({ range, to }: { range: string; to: string }): string => {
const ranges = range.split(',').map(parseRange);
const results = ranges.map(({ operator, version: ver }) => {
switch (operator) {
diff --git a/lib/versioning/ruby/strategies/pin.ts b/lib/versioning/ruby/strategies/pin.ts
index 2795633636..e7f7a12b60 100644
--- a/lib/versioning/ruby/strategies/pin.ts
+++ b/lib/versioning/ruby/strategies/pin.ts
@@ -1 +1 @@
-export default ({ to }: { to: string }) => to;
+export default ({ to }: { to: string }): string => to;
diff --git a/lib/versioning/ruby/strategies/replace.ts b/lib/versioning/ruby/strategies/replace.ts
index 927c9a7b1d..0fde62c4b3 100644
--- a/lib/versioning/ruby/strategies/replace.ts
+++ b/lib/versioning/ruby/strategies/replace.ts
@@ -1,7 +1,7 @@
import { satisfies } from '@snyk/ruby-semver';
import bump from './bump';
-export default ({ to, range }: { range: string; to: string }) => {
+export default ({ to, range }: { range: string; to: string }): string => {
if (satisfies(to, range)) {
return range;
}
diff --git a/lib/versioning/ruby/version.ts b/lib/versioning/ruby/version.ts
index e46d249b0a..edad649cef 100644
--- a/lib/versioning/ruby/version.ts
+++ b/lib/versioning/ruby/version.ts
@@ -16,13 +16,13 @@ const parse = (version: string): RubyVersion => ({
prerelease: prerelease(version),
});
-const adapt = (left: string, right: string) =>
+const adapt = (left: string, right: string): string =>
left
.split('.')
.slice(0, right.split('.').length)
.join('.');
-const floor = (version: string) =>
+const floor = (version: string): string =>
[
...create(version)
.release()
@@ -32,7 +32,7 @@ const floor = (version: string) =>
].join('.');
// istanbul ignore next
-const incrementLastSegment = (version: string) => {
+const incrementLastSegment = (version: string): string => {
const segments = create(version)
.release()
.getSegments();
@@ -47,14 +47,14 @@ const incrementMajor = (
min: number,
ptch: number,
pre: string[]
-) => (min === 0 || ptch === 0 || pre.length === 0 ? maj + 1 : maj);
+): number => (min === 0 || ptch === 0 || pre.length === 0 ? maj + 1 : maj);
// istanbul ignore next
-const incrementMinor = (min: number, ptch: number, pre: string[]) =>
+const incrementMinor = (min: number, ptch: number, pre: string[]): number =>
ptch === 0 || pre.length === 0 ? min + 1 : min;
// istanbul ignore next
-const incrementPatch = (ptch: number, pre: string[]) =>
+const incrementPatch = (ptch: number, pre: string[]): number =>
pre.length === 0 ? ptch + 1 : ptch;
// istanbul ignore next
diff --git a/lib/versioning/semver/index.ts b/lib/versioning/semver/index.ts
index cadf2f520a..9b068e3578 100644
--- a/lib/versioning/semver/index.ts
+++ b/lib/versioning/semver/index.ts
@@ -19,7 +19,7 @@ const {
} = semver;
// If this is left as an alias, inputs like "17.04.0" throw errors
-export const isVersion = (input: string) => valid(input);
+export const isVersion = (input: string): string => valid(input);
export { isVersion as isValid, maxSatisfyingVersion };
@@ -28,7 +28,7 @@ function getNewValue(
_rangeStrategy: RangeStrategy,
_fromVersion: string,
toVersion: string
-) {
+): string {
return toVersion;
}
diff --git a/lib/versioning/swift/index.ts b/lib/versioning/swift/index.ts
index 0f0df3a226..8ec6dcc2f9 100644
--- a/lib/versioning/swift/index.ts
+++ b/lib/versioning/swift/index.ts
@@ -20,16 +20,16 @@ const {
eq: equals,
} = semver;
-export const isValid = (input: string) =>
+export const isValid = (input: string): boolean =>
!!valid(input) || !!validRange(toSemverRange(input));
-export const isVersion = (input: string) => !!valid(input);
-const maxSatisfyingVersion = (versions: string[], range: string) =>
+export const isVersion = (input: string): boolean => !!valid(input);
+const maxSatisfyingVersion = (versions: string[], range: string): string =>
maxSatisfying(versions, toSemverRange(range));
-const minSatisfyingVersion = (versions: string[], range: string) =>
+const minSatisfyingVersion = (versions: string[], range: string): string =>
minSatisfying(versions, toSemverRange(range));
-const isLessThanRange = (version: string, range: string) =>
+const isLessThanRange = (version: string, range: string): boolean =>
ltr(version, toSemverRange(range));
-const matches = (version: string, range: string) =>
+const matches = (version: string, range: string): boolean =>
satisfies(version, toSemverRange(range));
export const api: VersioningApi = {
diff --git a/lib/versioning/swift/range.ts b/lib/versioning/swift/range.ts
index 9552cf4575..9bfaa6a4a2 100644
--- a/lib/versioning/swift/range.ts
+++ b/lib/versioning/swift/range.ts
@@ -6,7 +6,7 @@ const fromRange = /^\s*"([^"]+)"\s*\.\.\.\s*$/;
const binaryRange = /^\s*"([^"]+)"\s*(\.\.[.<])\s*"([^"]+)"\s*$/;
const toRange = /^\s*(\.\.[.<])\s*"([^"]+)"\s*$/;
-function toSemverRange(range: string) {
+function toSemverRange(range: string): string {
if (fromParam.test(range)) {
const [, version] = range.match(fromParam);
if (semver.valid(version)) {
@@ -39,7 +39,7 @@ function getNewValue(
_rangeStrategy: RangeStrategy,
_fromVersion: string,
toVersion: string
-) {
+): string {
if (fromParam.test(currentValue)) {
return toVersion;
}
diff --git a/lib/workers/branch/schedule.ts b/lib/workers/branch/schedule.ts
index c10be4b7de..c3ff3f3636 100644
--- a/lib/workers/branch/schedule.ts
+++ b/lib/workers/branch/schedule.ts
@@ -65,7 +65,7 @@ export function hasValidSchedule(
return [true, ''];
}
-export function isScheduledNow(config) {
+export function isScheduledNow(config): boolean {
let configSchedule = config.schedule;
logger.debug(`Checking schedule(${configSchedule}, ${config.timezone})`);
if (
diff --git a/lib/workers/branch/status-checks.ts b/lib/workers/branch/status-checks.ts
index c05704a788..e9dfc6c2b3 100644
--- a/lib/workers/branch/status-checks.ts
+++ b/lib/workers/branch/status-checks.ts
@@ -8,7 +8,7 @@ async function setStatusCheck(
context: string,
description: string,
state: string
-) {
+): Promise<void> {
const existingState = await platform.getBranchStatusCheck(
branchName,
context
@@ -33,7 +33,7 @@ export type StabilityConfig = RenovateConfig & {
branchName: string;
};
-export async function setStability(config: StabilityConfig) {
+export async function setStability(config: StabilityConfig): Promise<void> {
if (!config.stabilityStatus) {
return;
}
diff --git a/lib/workers/global/limits.ts b/lib/workers/global/limits.ts
index ed2f2cf670..0cf7d3052d 100644
--- a/lib/workers/global/limits.ts
+++ b/lib/workers/global/limits.ts
@@ -4,12 +4,12 @@ const limitsToInit = ['prCommitsPerRunLimit'];
const l: Record<string, number> = {};
const v: Record<string, number> = {};
-export function setLimit(name: string, value: number) {
+export function setLimit(name: string, value: number): void {
logger.debug(`Limits.setLimit l[${name}] = ${value}`);
l[name] = value;
}
-export function init(config: Record<string, any>) {
+export function init(config: Record<string, any>): void {
logger.debug(`Limits.init enter method`);
for (const limit of limitsToInit) {
logger.debug(`Limits.init ${limit} processing`);
@@ -24,7 +24,7 @@ export function init(config: Record<string, any>) {
}
}
-export function getLimitRemaining(name: string) {
+export function getLimitRemaining(name: string): number {
let result;
if (typeof v[name] !== 'undefined') {
result = l[name] - v[name];
@@ -34,7 +34,7 @@ export function getLimitRemaining(name: string) {
return result;
}
-export function incrementLimit(name: string, value = 1) {
+export function incrementLimit(name: string, value = 1): void {
if (typeof v[name] !== 'undefined') {
v[name] += value;
}
diff --git a/lib/workers/repository/onboarding/branch/check.ts b/lib/workers/repository/onboarding/branch/check.ts
index 2e6ee518a2..635643ce3b 100644
--- a/lib/workers/repository/onboarding/branch/check.ts
+++ b/lib/workers/repository/onboarding/branch/check.ts
@@ -36,7 +36,10 @@ const packageJsonConfigExists = async (): Promise<boolean> => {
return false;
};
-const closedPrExists = () =>
+// TODO: types
+export type Pr = any;
+
+const closedPrExists = (): Promise<Pr> =>
platform.findPr(onboardingBranch, onboardingPrTitle, '!open');
export const isOnboarded = async (config: RenovateConfig): Promise<boolean> => {
@@ -88,4 +91,5 @@ export const isOnboarded = async (config: RenovateConfig): Promise<boolean> => {
throw new Error('disabled');
};
-export const onboardingPrExists = () => platform.getBranchPr(onboardingBranch);
+export const onboardingPrExists = (): Promise<boolean> =>
+ platform.getBranchPr(onboardingBranch);
diff --git a/lib/workers/repository/process/lookup/index.ts b/lib/workers/repository/process/lookup/index.ts
index 6a9539373d..32c070a95c 100644
--- a/lib/workers/repository/process/lookup/index.ts
+++ b/lib/workers/repository/process/lookup/index.ts
@@ -109,7 +109,7 @@ function getFromVersion(
return version.maxSatisfyingVersion(useVersions, currentValue);
}
-function getBucket(config: LookupUpdateConfig, update: LookupUpdate) {
+function getBucket(config: LookupUpdateConfig, update: LookupUpdate): string {
const { separateMajorMinor, separateMultipleMajor } = config;
const { updateType, newMajor } = update;
if (updateType === 'lockfileUpdate') {
diff --git a/lib/workers/repository/updates/branchify.ts b/lib/workers/repository/updates/branchify.ts
index 15dc93ce9f..28e040750c 100644
--- a/lib/workers/repository/updates/branchify.ts
+++ b/lib/workers/repository/updates/branchify.ts
@@ -25,7 +25,7 @@ function cleanBranchName(branchName: string): string {
export function branchifyUpgrades(
config: RenovateConfig,
packageFiles: Record<string, any[]>
-) {
+): RenovateConfig {
logger.debug('branchifyUpgrades');
const updates = flattenUpdates(config, packageFiles);
logger.debug(
@@ -43,7 +43,8 @@ export function branchifyUpgrades(
update.currentVersion = update.currentValue;
update.newVersion = update.newVersion || update.newValue;
// massage for handlebars
- const upper = (str: string) => str.charAt(0).toUpperCase() + str.substr(1);
+ const upper = (str: string): string =>
+ str.charAt(0).toUpperCase() + str.substr(1);
if (update.updateType) {
update[`is${upper(update.updateType)}`] = true;
}
diff --git a/lib/workers/repository/updates/flatten.ts b/lib/workers/repository/updates/flatten.ts
index e8e3694d43..83d12cbacf 100644
--- a/lib/workers/repository/updates/flatten.ts
+++ b/lib/workers/repository/updates/flatten.ts
@@ -17,7 +17,7 @@ function getUpdateTypeRules(packageRules: PackageRule[]): PackageRule[] {
export function flattenUpdates(
config: RenovateConfig,
packageFiles: Record<string, any[]>
-) {
+): RenovateConfig[] {
const updates = [];
const updateTypes = [
'major',
diff --git a/lib/workers/repository/updates/generate.ts b/lib/workers/repository/updates/generate.ts
index 54b702c572..175a1ef754 100644
--- a/lib/workers/repository/updates/generate.ts
+++ b/lib/workers/repository/updates/generate.ts
@@ -3,7 +3,11 @@ import { DateTime } from 'luxon';
import semver from 'semver';
import mdTable from 'markdown-table';
import { logger } from '../../../logger';
-import { mergeChildConfig, ManagerConfig } from '../../../config';
+import {
+ mergeChildConfig,
+ ManagerConfig,
+ RenovateConfig,
+} from '../../../config';
import { PackageDependency } from '../../../manager/common';
function ifTypesGroup(
@@ -59,7 +63,7 @@ function getTableValues(
return null;
}
-export function generateBranchConfig(branchUpgrades) {
+export function generateBranchConfig(branchUpgrades): RenovateConfig {
logger.debug(`generateBranchConfig(${branchUpgrades.length})`);
logger.trace({ config: branchUpgrades });
let config: any = {
diff --git a/test/.eslintrc.js b/test/.eslintrc.js
index e75e9d6d4f..d7cc230f0a 100644
--- a/test/.eslintrc.js
+++ b/test/.eslintrc.js
@@ -12,5 +12,6 @@ module.exports = {
'@typescript-eslint/no-var-requires': 0,
'@typescript-eslint/no-object-literal-type-assertion': 0,
+ '@typescript-eslint/explicit-function-return-type': 0,
},
};
diff --git a/test/static-files.spec.ts b/test/static-files.spec.ts
index 4237df1a59..72f090a0cb 100644
--- a/test/static-files.spec.ts
+++ b/test/static-files.spec.ts
@@ -4,13 +4,13 @@ const glob = util.promisify(require('glob'));
const ignoredExtensions = ['js', 'ts', 'md', 'pyc', 'DS_Store', 'map'];
-function filterFiles(files: string[]) {
+function filterFiles(files: string[]): string[] {
return files.filter(file =>
ignoredExtensions.every(extension => !file.endsWith(`.${extension}`))
);
}
-async function getFiles(dir: string) {
+async function getFiles(dir: string): Promise<string[]> {
return filterFiles(await glob(`${dir}/**/*`, { dot: true, nodir: true })).map(
(file: string) => file.replace(`${dir}/`, '')
);
diff --git a/test/website-docs.spec.ts b/test/website-docs.spec.ts
index dc27a0268c..49fa105e9f 100644
--- a/test/website-docs.spec.ts
+++ b/test/website-docs.spec.ts
@@ -72,12 +72,14 @@ describe('docs', () => {
toContainOption(received, argument) {
if (received.includes(argument)) {
return {
- message: () => `Option "${argument}" should be within definitions`,
+ message: (): string =>
+ `Option "${argument}" should be within definitions`,
pass: true,
};
}
return {
- message: () => `Option "${argument}" doesn't exist within definitions`,
+ message: (): string =>
+ `Option "${argument}" doesn't exist within definitions`,
pass: false,
};
},
--
GitLab