feat(core): allow extending rulesets with aliases

packages/core/src/ruleset/validation/__tests__/__fixtures__/aliases/description-check.ts

@@ -0,0 +1,25 @@
+import { pattern } from '@stoplight/spectral-functions';
+import { DiagnosticSeverity } from '@stoplight/types';
+import { RulesetDefinition } from '@stoplight/spectral-core';
+
+export { ruleset as default };
+
+const ruleset: RulesetDefinition = {
+  aliases: {
+    infoSection: ['$.info.section'],
+  },
+  rules: {
+    'check-description': {
+      message: 'API version must be 1.0.0',
+      given: '#infoSection',
+      severity: DiagnosticSeverity.Error,
+      then: {
+        field: 'description',
+        function: pattern,
+        functionOptions: {
+          match: 'Stoplight',
+        },
+      },
+    },
+  },
+};

packages/core/src/ruleset/validation/__tests__/__fixtures__/aliases/extended-alias-collision.ts

@@ -0,0 +1,14 @@
+import { RulesetDefinition } from '@stoplight/spectral-core';
+
+import _scope from './scope';
+import _desc from './description-check';
+
+
+export { ruleset as default };
+
+const ruleset: RulesetDefinition = {
+  extends: [
+    _scope,
+    _desc,
+  ],
+};

packages/core/src/ruleset/validation/__tests__/__fixtures__/aliases/extended-definition.ts

@@ -0,0 +1,14 @@
+import { RulesetDefinition } from '@stoplight/spectral-core';
+
+import _scope from './scope';
+import _version from './version-check';
+
+
+export { ruleset as default };
+
+const ruleset: RulesetDefinition = {
+  extends: [
+    _scope,
+    _version,
+  ],
+};

packages/core/src/ruleset/validation/__tests__/__fixtures__/aliases/scope.ts

@@ -0,0 +1,61 @@
+import { DiagnosticSeverity } from '@stoplight/types';
+import { falsy, pattern, truthy } from '@stoplight/spectral-functions';
+import { RulesetDefinition } from '@stoplight/spectral-core';
+
+export { ruleset as default };
+
+const ruleset: RulesetDefinition = {
+  aliases: {
+    Stoplight: ['$..stoplight'],
+  },
+  overrides: [
+    {
+      files: ['*.yaml'],
+      rules: {
+        'value-matches-stoplight': {
+          message: 'Value must contain Stoplight',
+          given: '#Stoplight',
+          severity: DiagnosticSeverity.Error,
+          then: {
+            field: 'description',
+            function: pattern,
+            functionOptions: {
+              match: 'Stoplight',
+            },
+          },
+        },
+      },
+    },
+    {
+      files: ['**/*.json'],
+      aliases: {
+        Value: ['$..value'],
+      },
+      rules: {
+        'truthy-stoplight-property': {
+          message: 'Value must contain Stoplight',
+          given: '#Value',
+          severity: DiagnosticSeverity.Error,
+          then: {
+            function: truthy,
+          },
+        },
+      },
+    },
+    {
+      files: ['legacy/**/*.json'],
+      aliases: {
+        Value: ['$..value'],
+      },
+      rules: {
+        'falsy-value': {
+          given: '#Value',
+          severity: DiagnosticSeverity.Warning,
+          then: {
+            function: falsy,
+          },
+        },
+      },
+    },
+  ],
+};

packages/core/src/ruleset/validation/__tests__/__fixtures__/aliases/version-check.ts

@@ -0,0 +1,25 @@
+import { pattern } from '@stoplight/spectral-functions';
+import { DiagnosticSeverity } from '@stoplight/types';
+import { RulesetDefinition } from '@stoplight/spectral-core';
+
+export { ruleset as default };
+
+const ruleset: RulesetDefinition = {
+  aliases: {
+    infoSection: ['$.info'],
+  },
+  rules: {
+    'check-initial-version': {
+      message: 'API version must be 1.0.0',
+      given: '#infoSection',
+      severity: DiagnosticSeverity.Error,
+      then: {
+        field: 'version',
+        function: pattern,
+        functionOptions: {
+          match: '^1\\.0\\.0$',
+        },
+      },
+    },
+  },
+};

packages/core/src/ruleset/validation/__tests__/validation.test.ts

@@ -4,6 +4,8 @@ import { assertValidRuleset, RulesetValidationError } from '../index';
 import AggregateError = require('es-aggregate-error');
 import invalidRuleset from './__fixtures__/invalid-ruleset';
 import validRuleset from './__fixtures__/valid-flat-ruleset';
+import extendedRuleset from './__fixtures__/aliases/extended-definition';
+import aliasCollisionRuleset from './__fixtures__/aliases/extended-alias-collision';
 
 import type { Format } from '../../format';
 import { RulesetDefinition, RulesetOverridesDefinition } from '../../types';
@@ -63,6 +65,14 @@ describe('JS Ruleset Validation', () => {
     expect(assertValidRuleset.bind(null, validRuleset)).not.toThrow();
   });
 
+  it('given valid ruleset extending ruleset with alias should, emits no errors', () => {
+    expect(assertValidRuleset.bind(null, extendedRuleset)).not.toThrow();
+  });
+
+  it('given valid ruleset extending rulesets with alias collision should, emits no errors', () => {
+    expect(assertValidRuleset.bind(null, aliasCollisionRuleset)).not.toThrow();
+  });
+
   it.each([false, 2, null, 'foo', '12.foo.com'])(
     'given invalid %s documentationUrl in a rule, throws',
     documentationUrl => {

packages/core/src/ruleset/validation/validators/alias.ts

@@ -16,8 +16,54 @@ function getOverrides(overrides: unknown, key: string): Record<string, unknown>
   return isPlainObject(actualOverrides) && isPlainObject(actualOverrides.aliases) ? actualOverrides.aliases : null;
 }
 
+function getExtended(extended: Record<string, unknown>, parsedPath: string[]): Record<string, unknown> | null {
+  if (!Array.isArray(extended)) return null;
+
+  const key = parsedPath[1];
+  const index = Number(key);
+  if (Number.isNaN(index)) return null;
+  if (index < 0 && index >= extended.length) return null;
+
+  const actualExtended: Record<string, unknown> = extended[index] as Record<string, unknown>;
+  const aliases =
+    isPlainObject(actualExtended) && isPlainObject(actualExtended.aliases) ? actualExtended.aliases : null;
+
+  if (parsedPath.length >= 4 && parsedPath[2] === 'overrides') {
+    return {
+      ...aliases,
+      ...getOverrides(actualExtended.overrides, parsedPath[3]),
+    };
+  }
+
+  return aliases;
+}
+
+function getResolvedAliases(
+  parsedPath: string[],
+  ruleset: {
+    aliases?: Record<string, unknown>;
+    overrides?: Record<string, unknown>;
+    extends?: Record<string, unknown>;
+  },
+) {
+  if (parsedPath[0] === 'extends') {
+    return getExtended(ruleset.extends as Record<string, unknown>, parsedPath);
+  } else if (parsedPath[0] === 'overrides') {
+    return {
+      ...ruleset.aliases,
+      ...getOverrides(ruleset.overrides, parsedPath[1]),
+    };
+  } else {
+    return ruleset.aliases;
+  }
+}
+
 export function validateAlias(
-  ruleset: { aliases?: Record<string, unknown>; overrides?: Record<string, unknown> },
+  ruleset: {
+    aliases?: Record<string, unknown>;
+    overrides?: Record<string, unknown>;
+    extends?: Record<string, unknown>;
+  },
   alias: string,
   path: string,
 ): Error | void {
@@ -26,13 +72,7 @@ export function validateAlias(
   try {
     const formats: unknown = get(ruleset, [...parsedPath.slice(0, parsedPath.indexOf('rules') + 2), 'formats']);
 
-    const aliases =
-      parsedPath[0] === 'overrides'
-        ? {
-            ...ruleset.aliases,
-            ...getOverrides(ruleset.overrides, parsedPath[1]),
-          }
-        : ruleset.aliases;
+    const aliases = getResolvedAliases(parsedPath, ruleset);
 
     resolveAlias(aliases ?? null, alias, Array.isArray(formats) ? new Formats(formats) : null);
   } catch (ex) {