feat: PVP Version implementation for the Stack build tool (Haskell)

lib/versioning/api.ts

@@ -15,6 +15,7 @@ import * as npm from './npm';
 import * as nuget from './nuget';
 import * as pep440 from './pep440';
 import * as poetry from './poetry';
+import * as pvp from './pvp';
 import * as regex from './regex';
 import * as rez from './rez';
 import * as ruby from './ruby';
@@ -44,6 +45,7 @@ api.set('npm', npm.api);
 api.set('nuget', nuget.api);
 api.set('pep440', pep440.api);
 api.set('poetry', poetry.api);
+api.set('pvp', pvp.api);
 api.set('regex', regex.api);
 api.set('rez', rez.api);
 api.set('ruby', ruby.api);

lib/versioning/pvp/index.spec.ts

@@ -0,0 +1,73 @@
+import { api as pvp } from '.';
+
+describe('versioning/pvp/index', () => {
+  test.each`
+    version                                          | isValid
+    ${'0.1.0'}                                       | ${true}
+    ${'1.0.0'}                                       | ${true}
+    ${'0.0.1'}                                       | ${true}
+    ${'1.1.0.1.5.123455'}                            | ${true}
+    ${'1.2.3'}                                       | ${true}
+    ${'1.02.3'}                                      | ${false}
+    ${'1.04'}                                        | ${false}
+    ${'1.2.3-foo'}                                   | ${false}
+    ${'1.2.3foo'}                                    | ${false}
+    ${'~1.2.3'}                                      | ${false}
+    ${'^1.2.3'}                                      | ${false}
+    ${'>1.2.3'}                                      | ${false}
+    ${'one.two.three'}                               | ${false}
+    ${'renovatebot/renovate'}                        | ${false}
+    ${'renovatebot/renovate#main'}                   | ${false}
+    ${'https://github.com/renovatebot/renovate.git'} | ${false}
+  `('isValid("$version") === $isValid', ({ version, isValid }) => {
+    const res = !!pvp.isValid(version);
+    expect(res).toBe(isValid);
+  });
+
+  test.each`
+    input                        | expected
+    ${'9.0.3'}                   | ${true}
+    ${'1.2019.3.22'}             | ${true}
+    ${'3.0.0-beta'}              | ${false}
+    ${'2.0.2-pre20191018090318'} | ${false}
+    ${'1.0.0+c30d7625'}          | ${false}
+    ${'2.3.4-beta+1990ef74'}     | ${false}
+    ${'17.04'}                   | ${false}
+    ${'3.0.0.beta'}              | ${false}
+    ${'5.1.2-+'}                 | ${false}
+  `('isVersion("$input") === $expected', ({ input, expected }) => {
+    const res = !!pvp.isVersion(input);
+    expect(res).toBe(expected);
+  });
+
+  test.each`
+    input                        | expected
+    ${'9.0.3'}                   | ${true}
+    ${'1.2019.3.22'}             | ${true}
+    ${'3.0.0-beta'}              | ${false}
+    ${'2.0.2-pre20191018090318'} | ${false}
+    ${'1.0.0+c30d7625'}          | ${false}
+    ${'2.3.4-beta+1990ef74'}     | ${false}
+  `('isStable("$input") === $expected', ({ input, expected }) => {
+    expect(pvp.isStable(input)).toBe(expected);
+  });
+
+  test.each`
+    a            | b              | expected
+    ${'17.4.0'}  | ${'17.4.0'}    | ${true}
+    ${'1.4'}     | ${'1.4.0'}     | ${false}
+    ${'1.0.110'} | ${'1.0.110.0'} | ${false}
+    ${'1.0.0'}   | ${'1.0.0'}     | ${true}
+  `('equals($a, $b) === $expected', ({ a, b, expected }) => {
+    expect(pvp.equals(a, b)).toBe(expected);
+  });
+
+  test.each`
+    a          | b          | expected
+    ${'2.4.2'} | ${'2.4.1'} | ${true}
+    ${'1.9.0'} | ${'2.0.0'} | ${false}
+    ${'1.9.0'} | ${'1.9.1'} | ${false}
+  `('isGreaterThan($a, $b) === $expected', ({ a, b, expected }) => {
+    expect(pvp.isGreaterThan(a, b)).toBe(expected);
+  });
+});

lib/versioning/pvp/index.ts

@@ -0,0 +1,80 @@
+import { regEx } from '../../util/regex';
+import { GenericVersion, GenericVersioningApi } from '../loose/generic';
+import { VersioningApi } from '../types';
+
+export const id = 'pvp';
+export const displayName = 'PVP';
+export const urls = ['https://pvp.haskell.org'];
+export const supportsRanges = false;
+
+/**
+ * At least 3 components and no leading 0s
+ * https://pvp.haskell.org/#version-number
+ */
+const versionPattern = regEx(
+  /^((([0-9])|([1-9][0-9]*))\.){2,}(([0-9])|([1-9][0-9]*))$/
+);
+
+class PvpVersioningApi extends GenericVersioningApi {
+  /**
+   * PVP has two major components A.B
+   * To keep compatability with Renovate's versioning API we will treat it as a float
+   */
+  protected _parse(version: string): GenericVersion {
+    const matches = versionPattern.exec(version);
+    if (!matches) {
+      return null;
+    }
+
+    const components = version.split('.');
+    const major = parseFloat(`${components[0]}.${components[1]}`);
+    const rest = components.slice(2).map((i) => parseInt(i));
+    return { release: [major, ...rest] };
+  }
+
+  override getMajor(version: string): number | null {
+    const { release } = this._parse(version);
+    return parseFloat(`${release[0]}.${release[1]}`);
+  }
+
+  override getMinor(version: string): number | null {
+    const { release } = this._parse(version);
+    return release[2];
+  }
+
+  override getPatch(version: string): number | null {
+    const { release } = this._parse(version);
+    return release[3];
+  }
+
+  /**
+   * Compare similar to GenericVersioningApi._compare implementation
+   * except 2.1.1.0 and 2.1.1 are not equivilant instead 2.1.1.0 > 2.1.1
+   */
+  override _compare(version: string, other: string): number {
+    const left = this._parse(version);
+    const right = this._parse(other);
+
+    // istanbul ignore if
+    if (!(left && right)) {
+      return 1;
+    }
+
+    // support variable length compare
+    const length = Math.max(left.release.length, right.release.length);
+    for (let i = 0; i < length; i += 1) {
+      // 2.1.0 > 2.1
+      const part1 = left.release[i] ?? -1;
+      const part2 = right.release[i] ?? -1;
+      if (part1 !== part2) {
+        return part1 - part2;
+      }
+    }
+
+    return 0;
+  }
+}
+
+export const api: VersioningApi = new PvpVersioningApi();
+
+export default api;