refactor: from function to object

Author: rejmann

src/app/namespace/NamespaceBatchUpdater.ts

@@ -0,0 +1,45 @@
+import { MovedFileNamespaceUpdater } from './update/MovedFileNamespaceUpdater';
+import { MultiFileReferenceUpdater } from './update/MultiFileReferenceUpdater';
+import { NamespaceCreator } from '@domain/namespace/NamespaceCreator';
+import { Uri } from 'vscode';
+
+interface Props {
+  newUri: Uri,
+  oldUri: Uri,
+}
+
+export class NamespaceBatchUpdater {
+  public async execute({ newUri, oldUri }: Props) {
+    const namespaceCreator = new NamespaceCreator();
+    const {
+      namespace: newNamespace,
+      fullNamespace: useNewNamespace,
+    } = await namespaceCreator.execute({
+      uri: newUri,
+    });
+
+    if (!newNamespace) {
+      return;
+    }
+
+    const { fullNamespace: useOldNamespace } = await namespaceCreator.execute({
+      uri: oldUri,
+    });
+
+    const updated = await new MovedFileNamespaceUpdater().execute({
+      newNamespace,
+      newUri,
+    });
+
+    if (!updated) {
+      return;
+    }
+
+    await new MultiFileReferenceUpdater().execute({
+      useOldNamespace,
+      useNewNamespace,
+      newUri,
+      oldUri,
+    });
+  }
+}

src/app/namespace/openTextDocument.ts

@@ -0,0 +1,37 @@
+import { Range, Uri, workspace, WorkspaceEdit } from 'vscode';
+import { TextDocumentOpener } from '@app/services/TextDocumentOpener';
+
+interface Props {
+  newNamespace: string,
+  newUri: Uri,
+}
+
+export class MovedFileNamespaceUpdater {
+  public async execute({ newNamespace, newUri }: Props) {
+    const { document, text } = await new TextDocumentOpener().execute({ uri: newUri });
+
+    const namespaceRegex = /^\s*namespace\s+[\w\\]+;/m;
+    const match = text.match(namespaceRegex);
+
+    if (!match) {
+      return false;
+    }
+
+    const startIndex = match.index!;
+    const startPosition = document.positionAt(startIndex);
+    const endPosition = document.positionAt(startIndex + match[0].length);
+
+    const namespaceReplace = `\nnamespace ${newNamespace};`;
+
+    const edit = new WorkspaceEdit();
+    edit.replace(
+      newUri,
+      new Range(startPosition, endPosition),
+      namespaceReplace,
+    );
+
+    workspace.applyEdit(edit);
+
+    return true;
+  }
+}

src/app/namespace/remove/removeImports.ts

@@ -0,0 +1,115 @@
+import { Uri, workspace, WorkspaceEdit } from 'vscode';
+import { ImportRemover } from '@app/services/remove/ImportRemover';
+import { TextDocumentOpener } from '@app/services/TextDocumentOpener';
+import { UseStatementCreator } from '@domain/namespace/UseStatementCreator';
+import { UseStatementInjector } from '@domain/namespace/UseStatementInjector';
+import { UseStatementLocator } from '@domain/namespace/UseStatementLocator';
+import { WorkspaceFileFinder } from '@app/services/workspace/WorkspaceFileFinder';
+import { WorkspacePathResolver } from '@domain/workspace/WorkspacePathResolver';
+
+interface Props {
+  useOldNamespace: string
+  useNewNamespace: string
+  newUri: Uri
+  oldUri: Uri
+}
+
+export class MultiFileReferenceUpdater {
+  private workspacePathResolver: WorkspacePathResolver;
+
+  constructor() {
+    this.workspacePathResolver = new WorkspacePathResolver();
+  }
+
+  public async execute({
+    useOldNamespace,
+    useNewNamespace,
+    newUri,
+    oldUri,
+  }: Props) {
+    const directoryPath = this.workspacePathResolver.extractDirectoryFromPath(oldUri.fsPath);
+    const className = this.workspacePathResolver.extractClassNameFromPath(oldUri.fsPath);
+
+    const useImport = new UseStatementCreator().single({ fullNamespace: useNewNamespace });
+
+    const ignoreFile = newUri.fsPath;
+
+    const files = await new WorkspaceFileFinder().execute();
+
+    const filesToProcess = files.filter(file => ignoreFile !== file.fsPath);
+
+    await Promise.all(filesToProcess.map(async (file) => {
+      try {
+        const fileStream = workspace.fs;
+
+        await fileStream.stat(file);
+
+        const fileContent = await fileStream.readFile(file);
+        let text = Buffer.from(fileContent).toString();
+
+        if (!text.includes(useOldNamespace)) {
+          await this.updateInFile(
+            file,
+            directoryPath,
+            useImport,
+            className,
+          );
+
+          return;
+        }
+
+        text = text.replace(useOldNamespace, useNewNamespace);
+        await fileStream.writeFile(file, Buffer.from(text));
+
+        await this.updateInFile(
+          file,
+          directoryPath,
+          useImport,
+          className,
+        );
+      } catch (_) {
+        return;
+      }
+    }));
+
+    await new ImportRemover().execute({ uri: newUri });
+  }
+
+  private async updateInFile(
+    file: Uri,
+    oldDirectoryPath: string,
+    useImport: string,
+    className: string,
+  ): Promise<void> {
+      const currentDir = this.workspacePathResolver.extractDirectoryFromPath(file.fsPath);
+      if (oldDirectoryPath !== currentDir) {
+        return;
+      }
+
+      try {
+        const { document, text } = await new TextDocumentOpener().execute({ uri: file });
+
+        if (!text.includes(className)) {
+          return;
+        }
+
+        const insertionIndex = new UseStatementLocator().execute({ document });
+        if (insertionIndex === 0) {
+          return;
+        }
+
+        const edit = new WorkspaceEdit();
+
+        await new UseStatementInjector().save({
+          document,
+          workspaceEdit: edit,
+          uri: file,
+          lastUseEndIndex: insertionIndex,
+          useNamespace: useImport,
+          flush: true,
+        });
+      } catch (_) {
+        return;
+      }
+  }
+}