refactor: rename

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/UpdateAllService.ts

@@ -1,14 +1,14 @@
 import { Range, Uri, workspace, WorkspaceEdit } from 'vscode';
-import { OpenTextDocumentService } from '@app/services/OpenTextDocumentService';
+import { TextDocumentOpener } from '@app/services/TextDocumentOpener';
 
 interface Props {
   newNamespace: string,
   newUri: Uri,
 }
 
-export class MovedFileUpdateService {
+export class MovedFileNamespaceUpdater {
   public async execute({ newNamespace, newUri }: Props) {
-    const { document, text } = await new OpenTextDocumentService().execute({ uri: newUri });
+    const { document, text } = await new TextDocumentOpener().execute({ uri: newUri });
 
     const namespaceRegex = /^\s*namespace\s+[\w\\]+;/m;
     const match = text.match(namespaceRegex);

…mespace/update/MovedFileUpdateService.ts …pace/update/MovedFileNamespaceUpdater.tssrc/app/namespace/update/MovedFileUpdateService.ts renamed to src/app/namespace/update/MovedFileNamespaceUpdater.ts src/app/namespace/update/MovedFileUpdateService.ts renamed to src/app/namespace/update/MovedFileNamespaceUpdater.ts

@@ -1,11 +1,11 @@
 import { Uri, workspace, WorkspaceEdit } from 'vscode';
-import { CreateUseStatementService } from '@domain/namespace/CreateUseStatementService';
-import { FindWorkspaceFilesService } from '@app/services/workspace/FindWorkspaceFilesService';
-import { ImportRemoverService } from '@app/services/remove/ImportRemoverService';
-import { OpenTextDocumentService } from '@app/services/OpenTextDocumentService';
-import { UseStatementFinder } from '@domain/namespace/UseStatementFinder';
-import { UseStatementInserter } from '@domain/namespace/UseStatementInserter';
-import { WorkspacePathService } from '@domain/workspace/WorkspacePathService';
+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
@@ -14,11 +14,11 @@ interface Props {
   oldUri: Uri
 }
 
-export class ReferencesMultiFileUpdateService {
-  private workspacePathService: WorkspacePathService;
+export class MultiFileReferenceUpdater {
+  private workspacePathResolver: WorkspacePathResolver;
 
   constructor() {
-    this.workspacePathService = new WorkspacePathService();
+    this.workspacePathResolver = new WorkspacePathResolver();
   }
 
   public async execute({
@@ -27,14 +27,14 @@ export class ReferencesMultiFileUpdateService {
     newUri,
     oldUri,
   }: Props) {
-    const directoryPath = this.workspacePathService.extractDirectoryFromPath(oldUri.fsPath);
-    const className = this.workspacePathService.extractClassNameFromPath(oldUri.fsPath);
+    const directoryPath = this.workspacePathResolver.extractDirectoryFromPath(oldUri.fsPath);
+    const className = this.workspacePathResolver.extractClassNameFromPath(oldUri.fsPath);
 
-    const useImport = new CreateUseStatementService().single({ fullNamespace: useNewNamespace });
+    const useImport = new UseStatementCreator().single({ fullNamespace: useNewNamespace });
 
     const ignoreFile = newUri.fsPath;
 
-    const files = await new FindWorkspaceFilesService().execute();
+    const files = await new WorkspaceFileFinder().execute();
 
     const filesToProcess = files.filter(file => ignoreFile !== file.fsPath);
 
@@ -72,7 +72,7 @@ export class ReferencesMultiFileUpdateService {
       }
     }));
 
-    await new ImportRemoverService().execute({ uri: newUri });
+    await new ImportRemover().execute({ uri: newUri });
   }
 
   private async updateInFile(
@@ -81,26 +81,26 @@ export class ReferencesMultiFileUpdateService {
     useImport: string,
     className: string,
   ): Promise<void> {
-      const currentDir = this.workspacePathService.extractDirectoryFromPath(file.fsPath);
+      const currentDir = this.workspacePathResolver.extractDirectoryFromPath(file.fsPath);
       if (oldDirectoryPath !== currentDir) {
         return;
       }
 
       try {
-        const { document, text } = await new OpenTextDocumentService().execute({ uri: file });
+        const { document, text } = await new TextDocumentOpener().execute({ uri: file });
 
         if (!text.includes(className)) {
           return;
         }
 
-        const insertionIndex = new UseStatementFinder().execute({ document });
+        const insertionIndex = new UseStatementLocator().execute({ document });
         if (insertionIndex === 0) {
           return;
         }
 
         const edit = new WorkspaceEdit();
 
-        await new UseStatementInserter().save({
+        await new UseStatementInjector().save({
           document,
           workspaceEdit: edit,
           uri: file,

…date/ReferencesMultiFileUpdateService.ts …pace/update/MultiFileReferenceUpdater.tssrc/app/namespace/update/ReferencesMultiFileUpdateService.ts renamed to src/app/namespace/update/MultiFileReferenceUpdater.ts src/app/namespace/update/ReferencesMultiFileUpdateService.ts renamed to src/app/namespace/update/MultiFileReferenceUpdater.ts

@@ -0,0 +1,83 @@
+import { Uri, WorkspaceEdit } from 'vscode';
+import { promises as fs } from 'fs';
+import { PHP_EXTENSION } from '@infra/utils/constants';
+import { TextDocumentOpener } from '@app/services/TextDocumentOpener';
+import { UnusedImportDetector } from './import/UnusedImportDetector';
+import { UseStatementCreator } from '@domain/namespace/UseStatementCreator';
+import { UseStatementInjector } from '@domain/namespace/UseStatementInjector';
+import { UseStatementLocator } from '@domain/namespace/UseStatementLocator';
+import { WorkspacePathResolver } from '@domain/workspace/WorkspacePathResolver';
+
+interface Props {
+  oldUri: Uri
+  newUri: Uri
+}
+
+export class MissingClassImporter {
+  private workspacePathResolver: WorkspacePathResolver;
+
+  constructor() {
+    this.workspacePathResolver = new WorkspacePathResolver();
+  }
+
+  public async execute({ oldUri, newUri }: Props) {
+    const directoryPath = this.workspacePathResolver.extractDirectoryFromPath(oldUri.fsPath);
+    const classes = await this.getClassesNamesInDirectory(directoryPath);
+
+    if (classes.length < 1) {
+      return;
+    }
+
+    try {
+      const { document, text } = await new TextDocumentOpener().execute({ uri: newUri });
+
+      const imports = await new UseStatementCreator().multiple({
+        classesUsed: new UnusedImportDetector().execute({
+          contentDocument: text,
+          classes,
+        }),
+        directoryPath,
+      });
+
+      if (!imports || (directoryPath === this.workspacePathResolver.extractDirectoryFromPath(newUri.fsPath))) {
+        return;
+      }
+
+      const insertionIndex = new UseStatementLocator().execute({ document });
+      if (insertionIndex === 0) {
+        return;
+      }
+
+      const edit = new WorkspaceEdit();
+
+      const useStatementInjector = new UseStatementInjector();
+      for (const use of imports) {
+        await useStatementInjector.save({
+          document,
+          workspaceEdit: edit,
+          uri: newUri,
+          lastUseEndIndex: insertionIndex,
+          useNamespace: use,
+          flush: false,
+        });
+      }
+
+      if (imports.length > 0) {
+        await useStatementInjector.flush(edit);
+      }
+    } catch (_) {
+      return;
+    }
+  }
+
+  private async getClassesNamesInDirectory(directory: string): Promise<string[]> {
+    try {
+      const files = await fs.readdir(directory);
+      return files.filter(file => file.endsWith(PHP_EXTENSION))
+        .map(file => this.workspacePathResolver.extractClassNameFromPath(file))
+        .filter(Boolean);
+    } catch (_) {
+      return [];
+    }
+  }
+}

src/app/services/ImportMissingClassesService.ts

@@ -9,7 +9,7 @@ type OpenTextDocument = {
   text: string
 }
 
-export class OpenTextDocumentService {
+export class TextDocumentOpener {
   public async execute({ uri }: Props): Promise<OpenTextDocument> {
     const document = await workspace.openTextDocument(uri.fsPath);
     return {

src/app/services/MissingClassImporter.ts

@@ -3,7 +3,7 @@ interface Props {
   classes: string[],
 }
 
-export class UnimportedDetectionService {
+export class UnusedImportDetector {
   public execute({ contentDocument, classes }: Props): string[] {
     const classesUsed: string[] = [];