@spinnaker/eslint-plugin 3.0.0

package/utils/import-aliases.ts

@@ -0,0 +1,91 @@
+import * as fs from 'fs';
+import { flattenDeep, memoize } from 'lodash';
+import * as path from 'path';
+
+export function locateSourceFile(modulesPath: string, moduleName: string, importPath = '') {
+  const srcPrefixes = ['src', ''];
+  const indexFiles = ['', 'index'];
+  const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+
+  const paths = srcPrefixes.map((prefix) =>
+    extensions.map((extension) =>
+      indexFiles.map((indexFile) => {
+        return path.join(modulesPath, moduleName, prefix, importPath, indexFile) + extension;
+      }),
+    ),
+  );
+
+  return flattenDeep<string>(paths).find((p) => fs.existsSync(p));
+}
+
+function _getAllSpinnakerPackages(modulesPath: string) {
+  const paths = fs.readdirSync(modulesPath);
+  return paths
+    .map((file) => path.join(modulesPath, file))
+    .filter((child) => fs.statSync(child).isDirectory())
+    .map((packagePath) => packagePath.split('/').pop());
+}
+
+export const getAllSpinnakerPackages = memoize(_getAllSpinnakerPackages);
+
+function makeResult(pkg: string, importPath: string) {
+  const subPkg = getSubPackage(pkg, importPath);
+  importPath = importPath || '';
+  const importPathWithSlash = importPath ? '/' + importPath : '';
+  return pkg ? { pkg, subPkg, importPath, importPathWithSlash } : undefined;
+}
+
+/**
+ * Given '@spinnaker/amazon', returns { pkg: 'amazon', path: undefined };
+ * Given '@spinnaker/core/deep/import', returns { pkg: 'core', path: 'deep/import' };
+ * Given 'anythingelse', returns undefined
+ */
+export function getImportFromNpm(importString: string) {
+  const regexp = new RegExp(`^@spinnaker/([^/]+)(/.*)?$`);
+  const [, pkg, importPath] = regexp.exec(importString) || [];
+  return makeResult(pkg, importPath);
+}
+
+/**
+ * If code imports from a known spinnaker package alias
+ * Given 'amazon', returns { pkg: 'amazon', path: undefined };
+ * Given 'core/deep/import', returns { pkg: 'core', path: 'deep/import' };
+ * Given 'nonspinnakerpackage/deep/import', returns undefined
+ */
+export function getAliasImport(allSpinnakerPackages: string[], importString: string) {
+  const [, pkg, importPath] = /^([^/]+)\/(.*)$/.exec(importString) || [];
+  return allSpinnakerPackages.includes(pkg) ? makeResult(pkg, importPath) : undefined;
+}
+
+/**
+ * If code imports from .. relatively, returns the potential alias
+ * Assume all examples are from a file /packages/core/subdir/file.ts
+ * Given '../../amazon/loadbalancers/loadbalancer', returns { pkg: 'amazon', path: 'loadbalancers/loadbalancer' };
+ * Given '../widgets/button', returns { pkg: 'core', path: 'widgets/button' };
+ * Given './file2', returns { pkg: 'core', path: 'subdir/file2' };
+ */
+export function getRelativeImport(sourceFileName: string, modulesPath: string, importString: string) {
+  if (!importString.startsWith('../')) {
+    return undefined;
+  }
+
+  const resolvedPath = path.resolve(sourceFileName, importString);
+  const maybeImport = path.relative(modulesPath, resolvedPath);
+  const [pkg, ...rest] = maybeImport.split(path.sep);
+
+  return pkg ? makeResult(pkg, rest.join('/')) : undefined;
+}
+
+function _getSourceFileDetails(sourceFile: string) {
+  const [, modulesPath, ownPackage, filePath] = /^(.*packages)\/([^/]+)\/(?:src\/)?(.*)$/.exec(sourceFile) || [];
+  const ownSubPackage = getSubPackage(ownPackage, filePath);
+  const sourceDirectory = path.resolve(sourceFile, '..');
+  return { modulesPath, sourceDirectory, ownPackage, ownSubPackage, filePath };
+}
+
+function getSubPackage(_packageName: string, filePath: string) {
+  const [, subPkg] = /^([^/]+)\/?.*/.exec(filePath) || [];
+  return subPkg;
+}
+
+export const getSourceFileDetails = memoize(_getSourceFileDetails);

package/utils/mockModule.js

@@ -0,0 +1,15 @@
+/* eslint-disable no-undef */
+function mockModule(moduleName) {
+  jest.mock(moduleName);
+  const mockedModule = require(moduleName);
+  const actualModule = jest.requireActual(moduleName);
+  for (const [key, value] of Object.entries(actualModule)) {
+    if (typeof value === 'function') {
+      mockedModule[key].mockImplementation(value);
+    }
+  }
+
+  return require(moduleName);
+}
+
+module.exports = mockModule;

package/utils/ruleTester.js

@@ -0,0 +1,8 @@
+const RuleTester = require('eslint').RuleTester;
+module.exports = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 8,
+    sourceType: 'module',
+  },
+  parser: require.resolve('@typescript-eslint/parser'),
+});

package/utils/utils.ts

@@ -0,0 +1,90 @@
+import type { Rule, Scope } from 'eslint';
+import type {
+  CallExpression,
+  Expression,
+  Identifier,
+  Literal,
+  MemberExpression,
+  NewExpression,
+  Node,
+  Program,
+  SpreadElement,
+} from 'estree';
+import * as _ from 'lodash/fp';
+
+export const getNodeType = (obj: Node) => obj?.type;
+export const isType = <T extends Node>(type: string) => (obj: Node): obj is T => getNodeType(obj) === type;
+export const isIdentifier = isType<Identifier>('Identifier');
+export const isCallExpression = isType<CallExpression>('CallExpression');
+export const isMemberExpression = isType<MemberExpression>('MemberExpression');
+export const isLiteral = isType<Literal>('Literal');
+export const isNewExpression = isType<NewExpression>('NewExpression');
+
+/**
+ * Recursively grab the callee until an Identifier is found.
+ *
+ * API.all().all().one('foo/bar');
+ *
+ * var calleeOne = ...
+ * getCallingIdentifier(calleeOne).name === 'API'
+ */
+export function getCallingIdentifier(calleeObject: Node): Identifier {
+  if (isIdentifier(calleeObject)) {
+    return calleeObject;
+  }
+
+  if (isCallExpression(calleeObject)) {
+    const target = isMemberExpression(calleeObject.callee) ? calleeObject.callee.object : calleeObject.callee;
+    return getCallingIdentifier(target);
+  }
+
+  return undefined;
+}
+
+export function getCallingIdentifierName(calleeObject: Node) {
+  return getCallingIdentifier(calleeObject)?.name;
+}
+
+/**
+ * given an identifier, finds its Variable in the enclosing scope
+ */
+export function getVariableInScope(context: Rule.RuleContext, identifier: Identifier): Scope.Variable {
+  if (!isIdentifier(identifier)) {
+    return undefined;
+  }
+
+  const { references } = context.getScope();
+  const ref = references.find((r) => r.identifier.name === identifier.name);
+  return ref ? ref.resolved : undefined;
+}
+
+export const getVariableInitializer = _.get('defs[0].node.init');
+
+export function getProgram(node: Node): Program {
+  let _node = node as Node & Rule.NodeParentExtension;
+  while (_node.parent) {
+    if (_node.parent.type === 'Program') {
+      return _node.parent;
+    }
+    _node = _node.parent;
+  }
+  return undefined;
+}
+
+/**
+ * Given a CallExpression: API.one().two().three().get();
+ * Returns an array of the chained CallExpressions: [.one(), .two(), .three(), .get()]
+ */
+export const getCallChain = (node: Node): CallExpression[] => {
+  if (isCallExpression(node) && isMemberExpression(node.callee) && isCallExpression(node.callee.object)) {
+    return getCallChain(node.callee.object).concat(node);
+  } else if (isCallExpression(node)) {
+    return [node];
+  }
+  return [];
+};
+
+export function getArgsText(context: Rule.RuleContext, args: Array<Expression | SpreadElement>) {
+  const sourceCode = context.getSourceCode();
+  return (args || []).map((arg) => sourceCode.getText(arg)).join(', ');
+}