refactor: extract ProjectCleanupService

Author: rigor789

lib/bootstrap.ts

@@ -13,6 +13,10 @@ injector.requirePublic(
 	"projectConfigService",
 	"./services/project-config-service"
 );
+injector.requirePublic(
+	"projectCleanupService",
+	"./services/project-cleanup-service"
+);
 injector.require("performanceService", "./services/performance-service");
 injector.requirePublic("projectService", "./services/project-service");
 injector.require("androidProjectService", "./services/android-project-service");

lib/commands/clean.ts

@@ -1,17 +1,16 @@
-import * as path from "path";
 import { ICommand, ICommandParameter } from "../common/definitions/commands";
 import { injector } from "../common/yok";
-import { IFileSystem, IProjectHelper } from "../common/declarations";
 import * as constants from "../constants";
-import { IProjectConfigService } from "../definitions/project";
+import {
+	IProjectCleanupService,
+	IProjectConfigService,
+} from "../definitions/project";
 
 export class CleanCommand implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
 
 	constructor(
-		private $fs: IFileSystem,
-		private $logger: ILogger,
-		private $projectHelper: IProjectHelper,
+		private $projectCleanupService: IProjectCleanupService,
 		private $projectConfigService: IProjectConfigService,
 		private $terminalSpinnerService: ITerminalSpinnerService
 	) {}
@@ -34,48 +33,13 @@ export class CleanCommand implements ICommand {
 			if (Array.isArray(additionalPaths)) {
 				pathsToClean.push(...additionalPaths);
 			}
-
-			for (const pathToClean of pathsToClean) {
-				const filePath = path.resolve(
-					this.$projectHelper.projectDir,
-					pathToClean
-				);
-				const displayPath = `${path.relative(
-					this.$projectHelper.projectDir,
-					filePath
-				)}`.yellow;
-				spinner.start(`Cleaning ${displayPath}`);
-				this.$logger.trace(`Trying to clean '${filePath}'`);
-				if (this.$fs.exists(filePath)) {
-					const stat = this.$fs.getFsStats(filePath);
-
-					if (stat.isDirectory()) {
-						this.$logger.trace(`Path '${filePath}' is a directory, deleting.`);
-						this.$fs.deleteDirectorySafe(filePath);
-						spinner.text = `Cleaned directory ${displayPath}`;
-						spinner.succeed();
-					} else {
-						this.$logger.trace(`Path '${filePath}' is a file, deleting.`);
-						this.$fs.deleteFile(filePath);
-						spinner.text = `Cleaned file ${displayPath}`;
-						spinner.succeed();
-					}
-				} else {
-					spinner.text = `Skipping ${displayPath} because it doesn't exist.`;
-					spinner.info();
-					this.$logger.trace(`Path '${filePath}' not found, skipping.`);
-				}
-			}
 		} catch (err) {
-			// ignore any errors
-			this.$logger.trace(
-				`Encountered error while cleaning. Error is: ${err.message}.`,
-				err
-			);
+			// ignore
 		}
 
+		await this.$projectCleanupService.clean(pathsToClean);
+
 		spinner.succeed("Project successfully cleaned.");
-		// this.$logger.info("Project successfully cleaned.");
 	}
 }
 

lib/definitions/project.d.ts

@@ -293,6 +293,20 @@ interface IProjectDataService {
 	getNSValueFromContent(jsonData: Object, propertyName: string): any;
 }
 
+interface IProjectCleanupService {
+	/**
+	 * Clean multiple paths
+	 * @param {string[]} pathsToClean
+	 */
+	clean(pathsToClean: string[]): Promise<void>;
+
+	/**
+	 * Clean a single path
+	 * @param {string} pathToClean
+	 */
+	cleanPath(pathToClean: string): Promise<void>;
+}
+
 interface IProjectConfigInformation {
 	hasTSConfig: boolean;
 	hasJSConfig: boolean;

lib/services/project-cleanup-service.ts

@@ -0,0 +1,71 @@
+import { IProjectCleanupService } from "../definitions/project";
+import { IFileSystem, IProjectHelper } from "../common/declarations";
+import { injector } from "../common/yok";
+import * as path from "path";
+
+export class ProjectCleanupService implements IProjectCleanupService {
+	private spinner: ITerminalSpinner;
+
+	constructor(
+		private $fs: IFileSystem,
+		private $logger: ILogger,
+		private $projectHelper: IProjectHelper,
+		private $terminalSpinnerService: ITerminalSpinnerService
+	) {
+		this.spinner = this.$terminalSpinnerService.createSpinner();
+	}
+
+	public async clean(pathsToClean: string[]): Promise<void> {
+		for (const pathToClean of pathsToClean) {
+			await this.cleanPath(pathToClean).catch((error) => {
+				this.$logger.trace(
+					`Encountered error while cleaning. Error is: ${error.message}.`,
+					error
+				);
+			});
+		}
+	}
+
+	public async cleanPath(pathToClean: string): Promise<void> {
+		if (!pathToClean || pathToClean.trim().length === 0) {
+			this.$logger.trace("cleanPath called with no pathToClean.");
+			return;
+		}
+
+		const filePath = path.resolve(this.$projectHelper.projectDir, pathToClean);
+		const displayPath = `${path.relative(
+			this.$projectHelper.projectDir,
+			filePath
+		)}`.yellow;
+
+		this.spinner.start(`Cleaning ${displayPath}`);
+		this.$logger.trace(`Trying to clean '${filePath}'`);
+
+		if (this.$fs.exists(filePath)) {
+			const stat = this.$fs.getFsStats(filePath);
+
+			if (stat.isDirectory()) {
+				this.$logger.trace(`Path '${filePath}' is a directory, deleting.`);
+
+				this.$fs.deleteDirectorySafe(filePath);
+
+				this.spinner.text = `Cleaned directory ${displayPath}`;
+				this.spinner.succeed();
+			} else {
+				this.$logger.trace(`Path '${filePath}' is a file, deleting.`);
+
+				this.$fs.deleteFile(filePath);
+
+				this.spinner.text = `Cleaned file ${displayPath}`;
+				this.spinner.succeed();
+			}
+			return;
+		}
+
+		this.$logger.trace(`Path '${filePath}' not found, skipping.`);
+		this.spinner.text = `Skipping ${displayPath} because it doesn't exist.`;
+		this.spinner.info();
+	}
+}
+
+injector.register("projectCleanupService", ProjectCleanupService);