refactor(commands): drop what never shipped and the leftovers the review found

`executeCommandInProcess` and `canExecuteCommandInProcess` were renamed on
this branch before any release, so they go rather than stay deprecated; the
same for the `getInjector()` alias of `getRootInjector()`. The dispatcher's
hierarchical branch in option priming was unreachable once parent names were
routed to their leaf, the adapter shares `define-command`'s `isPlainObject`
instead of carrying a second one, the options service is typed in the
adapter, and `classCommandDefinition` is no longer exported.

Author: edusperoni

lib/common/define-command.ts

@@ -303,8 +303,14 @@ const invalid = (definition: any, problem: string): never => {
 	);
 };
 
-const isPlainObject = (value: any): boolean =>
-	!!value && typeof value === "object" && !Array.isArray(value);
+export function isPlainObject(value: unknown): boolean {
+	if (value === null || typeof value !== "object") {
+		return false;
+	}
+
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
 
 const validateName = (definition: any): void => {
 	const name = definition.name;
@@ -809,9 +815,7 @@ const buildClassDefinition = (ctor: any): DefinedCommand<any, any, any> => {
  * was read from. The cache entry is an own property so a class extending
  * another command class never serves its parent's definition.
  */
-export function classCommandDefinition(
-	ctor: any,
-): DefinedCommand<any, any, any> {
+function classCommandDefinition(ctor: any): DefinedCommand<any, any, any> {
 	if (!isCommandClass(ctor)) {
 		throw new Error(
 			`${describeDefinition(ctor)} is not a command class: it did not come ` +

lib/common/definitions/commands-service.d.ts

@@ -33,16 +33,6 @@ interface ICommandsService {
 		commandArguments?: string[],
 		options?: import("../contracts/commands-service").CommandDispatchOptions,
 	): Promise<boolean>;
-	/** @deprecated Use `runCommand`. */
-	executeCommandInProcess(
-		commandName: string,
-		commandArguments?: string[],
-	): Promise<void>;
-	/** @deprecated Use `canExecuteCommand`. */
-	canExecuteCommandInProcess(
-		commandName: string,
-		commandArguments?: string[],
-	): Promise<boolean>;
 }
 
 /**

lib/common/services/command-definition-adapter.ts

@@ -6,6 +6,7 @@ import { Injector } from "../di/injector";
 import { IDictionary, IDashedOption, IErrors } from "../declarations";
 import { ICommand } from "../definitions/commands";
 import { COMMAND_CONTEXT } from "../contracts/command-context";
+import { IOptions } from "../../declarations";
 import {
 	COMMAND_PRECONDITIONS,
 	CommandPrecondition,
@@ -39,17 +40,9 @@ import {
 	RegisterableCommand,
 	defineCommand,
 	toCommandDefinition,
+	isPlainObject,
 } from "../define-command";
 
-function isPlainObject(value: unknown): boolean {
-	if (value === null || typeof value !== "object") {
-		return false;
-	}
-
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-
 const OPTION_TYPES: IDictionary<OptionType> = {
 	boolean: OptionType.Boolean,
 	string: OptionType.String,
@@ -121,7 +114,7 @@ const warnOnCliOptionCollisions = (
 	targetInjector: Injector,
 	definition: CommandDefinition<any, any, any>,
 	schema: CommandOptionsSchema,
-	optionsService: any,
+	optionsService: IOptions | undefined,
 ): void => {
 	const cliOptions = optionsService && optionsService.options;
 	if (!cliOptions) {
@@ -217,7 +210,7 @@ export function createCommandFromDefinition<
 
 	// Only a definition that declares options may depend on the options service
 	// being registered - a bare command must work without one.
-	const optionsService: any = optionNames.length
+	const optionsService: IOptions | undefined = optionNames.length
 		? targetInjector.get("options")
 		: null;
 
@@ -284,7 +277,7 @@ export function createCommandFromDefinition<
 	const buildContext = (args: string[]): CommandContext<TSchema> => {
 		const options: any = {};
 		for (const optionName of optionNames) {
-			options[optionName] = optionsService[optionName];
+			options[optionName] = (<any>optionsService)[optionName];
 		}
 
 		return {

lib/common/services/commands-service.ts

@@ -453,22 +453,6 @@ export class CommandsService
 		return helpers.stringReplaceAll(name, "|", " ");
 	}
 
-	/** @deprecated Use {@link runCommand}. */
-	public executeCommandInProcess(
-		commandName: string,
-		commandArguments: string[] = [],
-	): Promise<void> {
-		return this.runCommand(commandName, commandArguments);
-	}
-
-	/** @deprecated Use {@link canExecuteCommand}. */
-	public canExecuteCommandInProcess(
-		commandName: string,
-		commandArguments: string[] = [],
-	): Promise<boolean> {
-		return this.canExecuteCommand(commandName, commandArguments);
-	}
-
 	/**
 	 * A name is looked up in the registry; a definition or class is run as the
 	 * caller holds it, registered or not, so what runs is what was referenced.
@@ -561,10 +545,6 @@ export class CommandsService
 	 * done. An in-process dispatch has to put the parser back where it found it.
 	 */
 	private primeOptions(command: ICommand): () => void {
-		if (command.isHierarchicalCommand) {
-			return () => undefined;
-		}
-
 		const declaredOptions = { ...this.$options.options };
 		const parsedArgv = this.$options.argv;
 

lib/common/yok.ts

@@ -750,11 +750,6 @@ export function getRootInjector(): IInjector {
 	return injector;
 }
 
-/** @deprecated Use getRootInjector(). */
-export function getInjector(): IInjector {
-	return getRootInjector();
-}
-
 /**
  * @deprecated Global-singleton wiring for the legacy facade; new code receives
  * the container via inject(Injector) instead of a process-wide global.

test/commands-service.ts

@@ -191,14 +191,14 @@ describe("commands-service", () => {
 		});
 	});
 
-	describe("executeCommandInProcess", () => {
+	describe("runCommand", () => {
 		it("primes the command's declared options before it runs", async () => {
 			const { injector, record } = createDispatchInjector(null);
 			const command = definedCommand(record, { allowUnknownOptions: true });
 			injector.resolveCommand = () => command;
 			const service = injector.resolve(CommandsService);
 
-			await service.executeCommandInProcess("open|ios");
+			await service.runCommand("open|ios");
 
 			assert.deepEqual(record.primedWith, [
 				{ dashedOptions: command.dashedOptions, allowUnknown: true },
@@ -212,7 +212,7 @@ describe("commands-service", () => {
 			injector.resolveCommand = () => definedCommand(record);
 			const service = injector.resolve(CommandsService);
 
-			await service.executeCommandInProcess("open|ios");
+			await service.runCommand("open|ios");
 
 			assert.deepEqual(options.options, { watch: cliOption });
 			assert.strictEqual(options.argv, initialArgv);
@@ -229,7 +229,7 @@ describe("commands-service", () => {
 				});
 			const service = injector.resolve(CommandsService);
 
-			await assert.isRejected(service.executeCommandInProcess("open|ios"));
+			await assert.isRejected(service.runCommand("open|ios"));
 
 			assert.deepEqual(options.options, { watch: cliOption });
 			assert.strictEqual(options.argv, initialArgv);
@@ -244,7 +244,7 @@ describe("commands-service", () => {
 			const service = injector.resolve(CommandsService);
 
 			await assert.isRejected(
-				service.executeCommandInProcess("open|ios"),
+				service.runCommand("open|ios"),
 				"Command 'open|ios' cannot be executed.",
 			);
 
@@ -258,7 +258,7 @@ describe("commands-service", () => {
 			const service = injector.resolve(CommandsService);
 
 			await assert.isRejected(
-				service.executeCommandInProcess("open|ios", ["extra"]),
+				service.runCommand("open|ios", ["extra"]),
 				"This command doesn't accept parameters.",
 			);
 
@@ -275,7 +275,7 @@ describe("commands-service", () => {
 				});
 			const service = injector.resolve(CommandsService);
 
-			await service.executeCommandInProcess("install", ["lodash"]);
+			await service.runCommand("install", ["lodash"]);
 
 			assert.deepEqual(record.executed, [["lodash"]]);
 			assert.deepEqual(record.postCommandActions, [["lodash"]]);
@@ -294,7 +294,7 @@ describe("commands-service", () => {
 
 			let raised: Error = null;
 			try {
-				await service.executeCommandInProcess("open|ios");
+				await service.runCommand("open|ios");
 			} catch (err) {
 				raised = err;
 			}
@@ -309,7 +309,7 @@ describe("commands-service", () => {
 			const service = injector.resolve(CommandsService);
 
 			await assert.isRejected(
-				service.executeCommandInProcess("nope"),
+				service.runCommand("nope"),
 				"Unknown command 'nope'.",
 			);
 
@@ -322,8 +322,8 @@ describe("commands-service", () => {
 			injector.resolveCommand = () => definedCommand(record);
 			const service = injector.resolve(CommandsService);
 
-			await service.executeCommandInProcess("open|ios");
-			await service.executeCommandInProcess("open|ios");
+			await service.runCommand("open|ios");
+			await service.runCommand("open|ios");
 
 			assert.deepEqual(record.executed, [[], []]);
 			assert.equal(record.primedWith.length, 2);
@@ -334,7 +334,7 @@ describe("commands-service", () => {
 			injector.resolveCommand = () => definedCommand(record);
 			const service = injector.resolve(CommandsService);
 
-			await service.executeCommandInProcess("open|ios");
+			await service.runCommand("open|ios");
 
 			assert.deepEqual(record.hooks, [
 				"before:open-ios",

test/compat/injector-facade-surface.ts

@@ -1,5 +1,5 @@
 import { assert } from "chai";
-import { Yok, getInjector } from "../../lib/common/yok";
+import { Yok, getRootInjector } from "../../lib/common/yok";
 import { Injector, inject, runInInjectionContext } from "../../lib/common/di";
 import {
 	CommandRegistry,
@@ -57,17 +57,17 @@ describe("injector facade surface", () => {
 		assert.strictEqual(sub.resolve("injector"), sub);
 	});
 
-	it("keeps getInjector() synchronized with a direct global.$injector assignment", () => {
-		const previous = getInjector();
+	it("keeps getRootInjector() synchronized with a direct global.$injector assignment", () => {
+		const previous = getRootInjector();
 		const fresh = new Yok();
 
 		(<any>global).$injector = fresh;
 		try {
-			assert.strictEqual(getInjector(), fresh);
+			assert.strictEqual(getRootInjector(), fresh);
 		} finally {
 			(<any>global).$injector = previous;
 		}
-		assert.strictEqual(getInjector(), previous);
+		assert.strictEqual(getRootInjector(), previous);
 	});
 
 	it("assigns the process-wide global.$injector", () => {

test/compat/legacy-hooks.ts

@@ -2,7 +2,7 @@ import { assert } from "chai";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { Yok, getInjector, setGlobalInjector } from "../../lib/common/yok";
+import { Yok, getRootInjector, setGlobalInjector } from "../../lib/common/yok";
 import { HooksService } from "../../lib/common/services/hooks-service";
 import { hook } from "../../lib/common/helpers";
 import { IInjector } from "../../lib/common/definitions/yok";
@@ -301,7 +301,7 @@ describe("legacy hook contract", () => {
 			}
 		}
 
-		const previousInjector = getInjector();
+		const previousInjector = getRootInjector();
 		setGlobalInjector(testInjector);
 		try {
 			const result = await new Subject().doWork();
@@ -328,7 +328,7 @@ describe("legacy hook contract", () => {
 			}
 		}
 
-		const previousInjector = getInjector();
+		const previousInjector = getRootInjector();
 		setGlobalInjector(<any>{
 			resolve: () => {
 				throw new Error("the process-wide injector must be the last resort");

test/define-command.ts

@@ -691,9 +691,7 @@ describe("defineCommand", () => {
 
 			const commandsService: ICommandsService =
 				testInjector.resolve("commandsService");
-			await commandsService.executeCommandInProcess(
-				"dctest-shortcuts-in-process",
-			);
+			await commandsService.runCommand("dctest-shortcuts-in-process");
 
 			assert.isTrue(ran);
 			assert.deepEqual(keyShortcutService.attached, []);

test/stubs.ts

@@ -1342,20 +1342,6 @@ export class CommandsService implements ICommandsService {
 		return Promise.resolve(true);
 	}
 
-	public executeCommandInProcess(
-		commandName: string,
-		commandArguments?: string[],
-	): Promise<void> {
-		return this.runCommand(commandName, commandArguments);
-	}
-
-	public canExecuteCommandInProcess(
-		commandName: string,
-		commandArguments?: string[],
-	): Promise<boolean> {
-		return this.canExecuteCommand(commandName, commandArguments);
-	}
-
 	public completeCommand(): Promise<boolean> {
 		return Promise.resolve(true);
 	}