Assassinate ASTFunctions (#148)

This is the third and last part of the refactor to the eslint plugin. With this part, we can finally delete the ASTFunctions file which was very long and a bit complicated to understand.

packages/eslint-plugin-obsidian/rules/dto/class.ts

@@ -25,12 +25,11 @@ export class Clazz {
     return this.node.body.body;
   }
 
-  public getDecoratedMethods(decoratorName: string) {
+  public getDecoratedMethods(decoratorName: string): Method[] {
     return this.body
       .filter(isMethodDefinition)
       .map((node) => new Method(node))
-      .filter((method) => method.isDecoratedWith(decoratorName))
-      .map((method) => method.name);
+      .filter((method) => method.isDecoratedWith(decoratorName));
   }
 
   public requireDecorator(name: string) {

packages/eslint-plugin-obsidian/rules/dto/method.ts

@@ -1,14 +1,19 @@
 import type { TSESTree } from '@typescript-eslint/types';
 import { Decorator } from './decorator';
+import { Parameter } from './parameter';
 
 export class Method {
 
-  constructor(private node: TSESTree.MethodDefinition) {}
+  constructor(public readonly node: TSESTree.MethodDefinition) {}
 
   get name() {
     return (this.node.key as TSESTree.Identifier).name;
   }
 
+  get parameters() {
+    return this.node.value.params.map((param) => new Parameter(param));
+  }
+
   isDecoratedWith(decoratorName: string): boolean {
     return this.decorators.some((decorator) => {
       return decorator.expression.callee.name === decoratorName;

packages/eslint-plugin-obsidian/rules/dto/parameter.ts

@@ -0,0 +1,9 @@
+import type { TSESTree } from '@typescript-eslint/types';
+
+export class Parameter {
+  constructor(public readonly node: TSESTree.Parameter) {}
+
+  get name() {
+    return (this.node as TSESTree.Identifier).name;
+  }
+}

packages/eslint-plugin-obsidian/rules/unresolvedProviderDependencies/dependencyResolver.ts

@@ -21,6 +21,8 @@ export class DependencyResolver {
   }
 
   private getGraphDependencies({ clazz }: ClassWithImports) {
-    return clazz.getDecoratedMethods('Provides');
+    return clazz
+      .getDecoratedMethods('Provides')
+      .map((method) => method.name);
   }
 }

packages/eslint-plugin-obsidian/rules/unresolvedProviderDependencies/graphHandler.ts

@@ -1,20 +1,22 @@
 import type { Clazz } from '../dto/class';
 import type { Context } from './types';
-import { checkDependencies } from './ASTFunctions';
 import { reportErrorIfDependencyIsUnresolved } from './errorReporter';
 import type { DependencyResolver } from './dependencyResolver';
 import type { Import } from '../dto/import';
+import { ResolvedDependencyChecker } from './resolvedDependencyChecker';
 
 export class GraphHandler {
   constructor(
     private context: Context,
     private dependencyResolver: DependencyResolver,
+    private resolvedDependencyChecker: ResolvedDependencyChecker = new ResolvedDependencyChecker(),
   ) { }
 
   public handle(clazz: Clazz, imports: Import[]) {
     if (this.hasGraphDecorator(clazz)) {
       const dependencies = this.dependencyResolver.resolve(clazz, imports);
-      reportErrorIfDependencyIsUnresolved(this.context, checkDependencies(clazz, dependencies));
+      const resolvedDependenciesCheck = this.resolvedDependencyChecker.check(clazz, dependencies);
+      reportErrorIfDependencyIsUnresolved(this.context, resolvedDependenciesCheck);
     }
   }
 

packages/eslint-plugin-obsidian/rules/unresolvedProviderDependencies/resolvedDependencyChecker.ts

@@ -0,0 +1,22 @@
+import type { Clazz } from '../dto/class';
+import type { Parameter } from '../dto/parameter';
+
+type DependencyCheckResult = { error: boolean; param?: string; node?: any };
+
+export class ResolvedDependencyChecker {
+
+  public check(clazz: Clazz, dependencies: string[]): DependencyCheckResult {
+    const unresolvedDependency = clazz
+      .getDecoratedMethods('Provides')
+      .flatMap((method) => method.parameters)
+      .find((provider) => !dependencies.includes(provider.name));
+  return this.getResult(unresolvedDependency);
+  }
+
+  private getResult(unresolvedDependency: Parameter | undefined): DependencyCheckResult {
+    if (unresolvedDependency) {
+      return { error: true, param: unresolvedDependency.name, node: unresolvedDependency.node };
+    }
+    return { error: false };
+  }
+}