feat: observer command and code lens

Author: raideer

package.json

@@ -57,6 +57,10 @@
       {
         "command": "magento-toolbox.generateXmlCatalog",
         "title": "Magento Toolbox: Generate XML URN Catalog"
+      },
+      {
+        "command": "magento-toolbox.generateObserver",
+        "title": "Magento Toolbox: Generate Observer"
       }
     ],
     "menus": {

src/codelens/ObserverCodelensProvider.ts

@@ -0,0 +1,72 @@
+import ObserverClassInfo from 'common/php/ObserverClassInfo';
+import PhpDocumentParser from 'common/php/PhpDocumentParser';
+import EventsIndexer from 'indexer/events/EventsIndexer';
+import IndexManager from 'indexer/IndexManager';
+import { NodeKind } from 'parser/php/Parser';
+import { Call } from 'php-parser';
+import Position from 'util/Position';
+import { CodeLens, CodeLensProvider, TextDocument } from 'vscode';
+
+export default class ObserverCodelensProvider implements CodeLensProvider {
+  public async provideCodeLenses(document: TextDocument): Promise<CodeLens[]> {
+    const codelenses: CodeLens[] = [];
+
+    const phpFile = await PhpDocumentParser.parse(document);
+
+    const observerClassInfo = new ObserverClassInfo(phpFile);
+
+    const eventDispatchCalls = observerClassInfo.getEventDispatchCalls();
+
+    if (eventDispatchCalls.length === 0) {
+      return codelenses;
+    }
+
+    codelenses.push(...this.getEventDispatchCodeLenses(eventDispatchCalls));
+
+    return codelenses;
+  }
+
+  private getEventDispatchCodeLenses(eventDispatchCalls: Call[]): CodeLens[] {
+    const eventsIndexData = IndexManager.getIndexData(EventsIndexer.KEY);
+
+    if (!eventsIndexData) {
+      return [];
+    }
+
+    const codelenses: CodeLens[] = [];
+
+    for (const eventDispatchCall of eventDispatchCalls) {
+      const args = eventDispatchCall.arguments;
+
+      if (args.length === 0) {
+        continue;
+      }
+
+      const firstArg = args[0];
+
+      if (!firstArg || firstArg.kind !== NodeKind.String || !firstArg.loc) {
+        continue;
+      }
+
+      const eventName = (firstArg as any).value;
+
+      const event = eventsIndexData.getEventByName(eventName);
+
+      if (!event) {
+        continue;
+      }
+
+      const range = Position.phpAstLocationToVsCodeRange(firstArg.loc);
+
+      const codelens = new CodeLens(range, {
+        title: 'Create an Observer',
+        command: 'magento-toolbox.generateObserver',
+        arguments: [event.name],
+      });
+
+      codelenses.push(codelens);
+    }
+
+    return codelenses;
+  }
+}

src/command/GenerateModuleCommand.ts

@@ -3,10 +3,11 @@ import ModuleXmlGenerator from 'generator/module/ModuleXmlGenerator';
 import ModuleRegistrationGenerator from 'generator/module/ModuleRegistrationGenerator';
 import ModuleComposerGenerator from 'generator/module/ModuleComposerGenerator';
 import ModuleLicenseGenerator from 'generator/module/ModuleLicenseGenerator';
-import ModuleWizard from 'wizard/ModuleWizard';
+import ModuleWizard, { ModuleWizardData, ModuleWizardComposerData } from 'wizard/ModuleWizard';
 import FileGeneratorManager from 'generator/FileGeneratorManager';
 import { window } from 'vscode';
 import Common from 'util/Common';
+import WizzardClosedError from 'webview/error/WizzardClosedError';
 
 export default class GenerateModuleCommand extends Command {
   constructor() {
@@ -16,7 +17,17 @@ export default class GenerateModuleCommand extends Command {
   public async execute(...args: any[]): Promise<void> {
     const moduleWizard = new ModuleWizard();
 
-    const data = await moduleWizard.show();
+    let data: ModuleWizardData | ModuleWizardComposerData;
+
+    try {
+      data = await moduleWizard.show();
+    } catch (error) {
+      if (error instanceof WizzardClosedError) {
+        return;
+      }
+
+      throw error;
+    }
 
     const manager = new FileGeneratorManager([
       new ModuleXmlGenerator(data),

src/command/GenerateObserverCommand.ts

@@ -0,0 +1,47 @@
+import { Command } from 'command/Command';
+import ObserverWizard, { ObserverWizardData } from 'wizard/ObserverWizard';
+import WizzardClosedError from 'webview/error/WizzardClosedError';
+import FileGeneratorManager from 'generator/FileGeneratorManager';
+import Common from 'util/Common';
+import { window } from 'vscode';
+import ObserverClassGenerator from 'generator/observer/ObserverClassGenerator';
+import ObserverEventsGenerator from 'generator/observer/ObserverEventsGenerator';
+
+export default class GenerateObserverCommand extends Command {
+  constructor() {
+    super('magento-toolbox.generateObserver');
+  }
+
+  public async execute(eventName?: string): Promise<void> {
+    const observerWizard = new ObserverWizard();
+
+    let data: ObserverWizardData;
+
+    try {
+      data = await observerWizard.show(eventName);
+    } catch (error) {
+      if (error instanceof WizzardClosedError) {
+        return;
+      }
+
+      throw error;
+    }
+
+    const manager = new FileGeneratorManager([
+      new ObserverClassGenerator(data),
+      new ObserverEventsGenerator(data),
+    ]);
+
+    const workspaceFolder = Common.getActiveWorkspaceFolder();
+
+    if (!workspaceFolder) {
+      window.showErrorMessage('No active workspace folder');
+      return;
+    }
+
+    await manager.generate(workspaceFolder.uri);
+    await manager.writeFiles();
+    await manager.refreshIndex(workspaceFolder);
+    manager.openFirstFile();
+  }
+}

src/common/Validation.ts

@@ -0,0 +1,37 @@
+export interface ValidationResult {
+  isValid: boolean;
+  errors?: string[];
+}
+
+export default class Validation {
+  public static readonly MODULE_NAME_REGEX = /^[A-Z][a-z0-9]*_[A-Z][a-z0-9]*$/;
+  public static readonly CLASS_NAME_REGEX = /^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/;
+  public static readonly SNAKE_CASE_REGEX = /^[a-z0-9_]+$/;
+
+  public static isValidModuleName(name: string): ValidationResult {
+    if (!Validation.MODULE_NAME_REGEX.test(name)) {
+      return {
+        isValid: false,
+        errors: ['Module name must be in format "Vendor_Module"'],
+      };
+    }
+
+    return { isValid: true };
+  }
+
+  public static isValidClassName(name: string): ValidationResult {
+    if (!Validation.CLASS_NAME_REGEX.test(name)) {
+      return { isValid: false, errors: ['Class name must be in format "ClassName"'] };
+    }
+
+    return { isValid: true };
+  }
+
+  public static isSnakeCase(name: string): ValidationResult {
+    if (!Validation.SNAKE_CASE_REGEX.test(name)) {
+      return { isValid: false, errors: ['Name must be in snake_case format'] };
+    }
+
+    return { isValid: true };
+  }
+}

src/extension.ts

@@ -15,6 +15,8 @@ import CopyMagentoPathCommand from 'command/CopyMagentoPathCommand';
 import Common from 'util/Common';
 import GenerateXmlCatalogCommand from 'command/GenerateXmlCatalogCommand';
 import XmlClasslikeHoverProvider from 'hover/XmlClasslikeHoverProvider';
+import ObserverCodelensProvider from 'codelens/ObserverCodelensProvider';
+import GenerateObserverCommand from 'command/GenerateObserverCommand';
 
 // This method is called when your extension is activated
 // Your extension is activated the very first time the command is executed
@@ -27,6 +29,7 @@ export async function activate(context: vscode.ExtensionContext) {
     GenerateContextPluginCommand,
     CopyMagentoPathCommand,
     GenerateXmlCatalogCommand,
+    GenerateObserverCommand,
   ];
 
   ExtensionState.init(context);
@@ -86,6 +89,11 @@ export async function activate(context: vscode.ExtensionContext) {
     vscode.languages.registerDefinitionProvider('xml', new XmlClasslikeDefinitionProvider())
   );
 
+  // codelens providers
+  context.subscriptions.push(
+    vscode.languages.registerCodeLensProvider('php', new ObserverCodelensProvider())
+  );
+
   // hover providers
   context.subscriptions.push(
     vscode.languages.registerHoverProvider('xml', new XmlClasslikeHoverProvider())

src/generator/observer/ObserverClassGenerator.ts

@@ -0,0 +1,45 @@
+import PhpNamespace from 'common/PhpNamespace';
+import GeneratedFile from 'generator/GeneratedFile';
+import ModuleFileGenerator from 'generator/ModuleFileGenerator';
+import { PhpFile, PsrPrinter } from 'node-php-generator';
+import { Uri } from 'vscode';
+import { ObserverWizardData } from 'wizard/ObserverWizard';
+
+export default class ObserverClassGenerator extends ModuleFileGenerator {
+  private static readonly OBSERVER_INTERFACE = 'Magento\\Framework\\Event\\ObserverInterface';
+  private static readonly OBSERVER_CLASS = 'Magento\\Framework\\Event\\Observer';
+
+  public constructor(protected data: ObserverWizardData) {
+    super();
+  }
+
+  public async generate(workspaceUri: Uri): Promise<GeneratedFile> {
+    const [vendor, module] = this.data.module.split('_');
+    const namespaceParts = [vendor, module, this.data.directoryPath];
+    const moduleDirectory = this.getModuleDirectory(vendor, module, workspaceUri);
+
+    const phpFile = new PhpFile();
+    phpFile.setStrictTypes(true);
+
+    const namespace = phpFile.addNamespace(PhpNamespace.fromParts(namespaceParts).toString());
+    namespace.addUse(ObserverClassGenerator.OBSERVER_INTERFACE);
+    namespace.addUse(ObserverClassGenerator.OBSERVER_CLASS);
+
+    const observerClass = namespace.addClass(this.data.className);
+    observerClass.addImplement(ObserverClassGenerator.OBSERVER_INTERFACE);
+
+    const observerMethod = observerClass.addMethod('execute');
+    observerMethod.addParameter('observer').setType(ObserverClassGenerator.OBSERVER_CLASS);
+    observerMethod.addComment(`Observer for "${this.data.eventName}"\n`);
+    observerMethod.addComment('@param Observer $observer');
+    observerMethod.addComment('@return void');
+    observerMethod.setBody(`$event = $observer->getEvent();\n// TODO: Observer code`);
+
+    const printer = new PsrPrinter();
+
+    return new GeneratedFile(
+      Uri.joinPath(moduleDirectory, this.data.directoryPath, `${this.data.className}.php`),
+      printer.printFile(phpFile)
+    );
+  }
+}

src/generator/observer/ObserverEventsGenerator.ts

@@ -0,0 +1,50 @@
+import GeneratedFile from 'generator/GeneratedFile';
+import ModuleFileGenerator from 'generator/ModuleFileGenerator';
+import GenerateFromTemplate from 'generator/util/GenerateFromTemplate';
+import { Uri } from 'vscode';
+import { ObserverWizardData } from 'wizard/ObserverWizard';
+import indentString from 'indent-string';
+import PhpNamespace from 'common/PhpNamespace';
+import FindOrCreateEventsXml from 'generator/util/FindOrCreateEventsXml';
+import { MagentoScope } from 'types';
+
+export default class ObserverDiGenerator extends ModuleFileGenerator {
+  public constructor(protected data: ObserverWizardData) {
+    super();
+  }
+
+  public async generate(workspaceUri: Uri): Promise<GeneratedFile> {
+    const [vendor, module] = this.data.module.split('_');
+    const moduleDirectory = this.getModuleDirectory(vendor, module, workspaceUri);
+    const observerNamespace = PhpNamespace.fromParts([vendor, module, this.data.directoryPath]);
+    const areaPath = this.data.area === MagentoScope.Global ? '' : this.data.area;
+
+    const eventsFile = Uri.joinPath(moduleDirectory, 'etc', areaPath, 'events.xml');
+    const eventsXml = await FindOrCreateEventsXml.execute(
+      workspaceUri,
+      vendor,
+      module,
+      this.data.area
+    );
+    const insertPosition = this.getInsertPosition(eventsXml);
+
+    const observerXml = await GenerateFromTemplate.generate('xml/observer', {
+      name: this.data.observerName,
+      className: observerNamespace.append(this.data.className).toString(),
+      eventName: this.data.eventName,
+    });
+
+    const newEventsXml =
+      eventsXml.slice(0, insertPosition) +
+      '\n' +
+      indentString(observerXml, 4) +
+      '\n' +
+      eventsXml.slice(insertPosition);
+
+    return new GeneratedFile(eventsFile, newEventsXml, false);
+  }
+
+  private getInsertPosition(diXml: string): number {
+    return diXml.indexOf('</config>');
+  }
+}

src/generator/util/FindOrCreateDiXml.ts

@@ -2,8 +2,8 @@ import { Uri } from 'vscode';
 import FileSystem from 'util/FileSystem';
 import GenerateFromTemplate from './GenerateFromTemplate';
 
-class FindOrCreateDiXml {
-  public async execute(workspaceUri: Uri, vendor: string, module: string): Promise<string> {
+export default class FindOrCreateDiXml {
+  public static async execute(workspaceUri: Uri, vendor: string, module: string): Promise<string> {
     const diFile = Uri.joinPath(workspaceUri, 'app', 'code', vendor, module, 'etc', 'di.xml');
 
     if (await FileSystem.fileExists(diFile)) {
@@ -13,5 +13,3 @@ class FindOrCreateDiXml {
     return await GenerateFromTemplate.generate('xml/blank-di');
   }
 }
-
-export default new FindOrCreateDiXml();

src/generator/util/FindOrCreateEventsXml.ts

@@ -0,0 +1,31 @@
+import { Uri } from 'vscode';
+import FileSystem from 'util/FileSystem';
+import GenerateFromTemplate from './GenerateFromTemplate';
+import { MagentoScope } from 'types';
+
+export default class FindOrCreateEventsXml {
+  public static async execute(
+    workspaceUri: Uri,
+    vendor: string,
+    module: string,
+    area: MagentoScope
+  ): Promise<string> {
+    const areaPath = area === MagentoScope.Global ? '' : area;
+    const eventsFile = Uri.joinPath(
+      workspaceUri,
+      'app',
+      'code',
+      vendor,
+      module,
+      'etc',
+      areaPath,
+      'events.xml'
+    );
+
+    if (await FileSystem.fileExists(eventsFile)) {
+      return await FileSystem.readFile(eventsFile);
+    }
+
+    return await GenerateFromTemplate.generate('xml/blank-events');
+  }
+}