Merge branch 'master' of github-magebit:magebitcom/magento-toolbox into feature/xml-snippets

Author: raideer

CHANGELOG.md

@@ -4,9 +4,12 @@ All notable changes to the "magento-toolbox" extension will be documented in thi
 
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
-## [Unreleased]
+## [1.6.0] - 2025-04-09
 
 - Added: Event name autocomplete
+- Added: Hovering CRON job schedules will show a human readable version
+- Added: Cron job indexer and instance class decorations
+- Changed: Implemented batching for the indexer to reduce load
 
 ## [1.5.0] - 2025-04-06
 - Added: Class namespace autocomplete in XML files

package-lock.json

@@ -4,7 +4,7 @@
   "description": "Magento 2 code generation, inspection and utility tools",
   "publisher": "magebit",
   "icon": "resources/logo.jpg",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "engines": {
     "vscode": "^1.93.1"
   },
@@ -427,6 +427,7 @@
     "@xml-tools/parser": "^1.0.11",
     "@xml-tools/simple-schema": "^3.0.5",
     "@xml-tools/validation": "^1.0.16",
+    "cronstrue": "^2.59.0",
     "fast-xml-parser": "^4.5.1",
     "formik": "^2.4.6",
     "glob": "^11.0.1",

package.json

@@ -0,0 +1,91 @@
+import { DecorationOptions, TextEditorDecorationType, Uri, window } from 'vscode';
+import path from 'path';
+import TextDocumentDecorationProvider from './TextDocumentDecorationProvider';
+import { PhpClass } from 'parser/php/PhpClass';
+import { PhpInterface } from 'parser/php/PhpInterface';
+import PhpDocumentParser from 'common/php/PhpDocumentParser';
+import { ClasslikeInfo } from 'common/php/ClasslikeInfo';
+import MarkdownMessageBuilder from 'common/MarkdownMessageBuilder';
+import IndexManager from 'indexer/IndexManager';
+import CronIndexer from 'indexer/cron/CronIndexer';
+import { Job } from 'indexer/cron/types';
+import cronstrue from 'cronstrue';
+
+export default class CronClassDecorationProvider extends TextDocumentDecorationProvider {
+  public getType(): TextEditorDecorationType {
+    return window.createTextEditorDecorationType({
+      gutterIconPath: path.join(__dirname, 'resources', 'icons', 'cron.svg'),
+      gutterIconSize: '80%',
+      borderColor: 'rgba(0, 188, 202, 0.5)',
+      borderStyle: 'dotted',
+      borderWidth: '0 0 1px 0',
+    });
+  }
+
+  public async getDecorations(): Promise<DecorationOptions[]> {
+    const decorations: DecorationOptions[] = [];
+    const phpFile = await PhpDocumentParser.parse(this.document);
+
+    const classLikeNode: PhpClass | PhpInterface | undefined =
+      phpFile.classes[0] || phpFile.interfaces[0];
+
+    if (!classLikeNode) {
+      return decorations;
+    }
+
+    const classlikeInfo = new ClasslikeInfo(phpFile);
+
+    const cronIndexData = IndexManager.getIndexData(CronIndexer.KEY);
+
+    if (!cronIndexData) {
+      return decorations;
+    }
+
+    const jobs = cronIndexData.findJobsByInstance(classlikeInfo.getNamespace());
+
+    if (jobs.length === 0) {
+      return decorations;
+    }
+
+    decorations.push(...this.getCronInstanceDecorations(jobs, classlikeInfo));
+
+    return decorations;
+  }
+
+  private getCronInstanceDecorations(
+    jobs: Job[],
+    classlikeInfo: ClasslikeInfo
+  ): DecorationOptions[] {
+    const decorations: DecorationOptions[] = [];
+
+    const nameRange = classlikeInfo.getNameRange();
+
+    if (!nameRange) {
+      return decorations;
+    }
+
+    const hoverMessage = MarkdownMessageBuilder.create('Cron Jobs');
+
+    for (const job of jobs) {
+      hoverMessage.appendMarkdown(`- [${job.name}](${Uri.file(job.path)})\n`);
+      hoverMessage.appendMarkdown(`  - Method: \`${job.method}\`\n`);
+
+      if (job.schedule) {
+        hoverMessage.appendMarkdown(
+          `  - \`${job.schedule}\` (${cronstrue.toString(job.schedule)})\n`
+        );
+      }
+
+      if (job.config_path) {
+        hoverMessage.appendMarkdown(`  - Config: \`${job.config_path}\`\n`);
+      }
+    }
+
+    decorations.push({
+      range: nameRange,
+      hoverMessage: hoverMessage.build(),
+    });
+
+    return decorations;
+  }
+}

resources/icons/cron.svg

@@ -2,10 +2,11 @@ import { CancellationToken, Hover, Position, TextDocument } from 'vscode';
 import { XmlSuggestionProviderProcessor } from 'common/xml/XmlSuggestionProviderProcessor';
 import { AclHoverProvider } from 'hover/xml/AclHoverProvider';
 import { ModuleHoverProvider } from 'hover/xml/ModuleHoverProvider';
+import { CronHoverProvider } from 'hover/xml/CronHoverProvider';
 
 export class XmlHoverProviderProcessor extends XmlSuggestionProviderProcessor<Hover> {
   public constructor() {
-    super([new AclHoverProvider(), new ModuleHoverProvider()]);
+    super([new AclHoverProvider(), new ModuleHoverProvider(), new CronHoverProvider()]);
   }
 
   public async provideHover(

src/decorator/CronClassDecorationProvider.ts

@@ -0,0 +1,31 @@
+import { Hover, MarkdownString, Range } from 'vscode';
+import { CombinedCondition, XmlSuggestionProvider } from 'common/xml/XmlSuggestionProvider';
+import { ElementNameMatches } from 'common/xml/suggestion/condition/ElementNameMatches';
+import cronstrue from 'cronstrue';
+
+export class CronHoverProvider extends XmlSuggestionProvider<Hover> {
+  public getElementContentMatches(): CombinedCondition[] {
+    return [[new ElementNameMatches('schedule')]];
+  }
+
+  public getConfigKey(): string | undefined {
+    return 'provideXmlHovers';
+  }
+
+  public getFilePatterns(): string[] {
+    return ['**/etc/crontab.xml'];
+  }
+
+  public getSuggestionItems(value: string, range: Range): Hover[] {
+    const readable = cronstrue.toString(value);
+
+    if (!readable) {
+      return [];
+    }
+
+    const markdown = new MarkdownString();
+    markdown.appendMarkdown(`**Cron**: ${readable}`);
+
+    return [new Hover(markdown, range)];
+  }
+}

src/hover/XmlHoverProviderProcessor.ts

@@ -18,14 +18,17 @@ import AclIndexer from './acl/AclIndexer';
 import { AclIndexData } from './acl/AclIndexData';
 import TemplateIndexer from './template/TemplateIndexer';
 import { TemplateIndexData } from './template/TemplateIndexData';
+import CronIndexer from './cron/CronIndexer';
+import { CronIndexData } from './cron/CronIndexData';
 
 type IndexerInstance =
   | DiIndexer
   | ModuleIndexer
   | AutoloadNamespaceIndexer
   | EventsIndexer
   | AclIndexer
-  | TemplateIndexer;
+  | TemplateIndexer
+  | CronIndexer;
 
 type IndexerDataMap = {
   [DiIndexer.KEY]: DiIndexData;
@@ -34,9 +37,12 @@ type IndexerDataMap = {
   [EventsIndexer.KEY]: EventsIndexData;
   [AclIndexer.KEY]: AclIndexData;
   [TemplateIndexer.KEY]: TemplateIndexData;
+  [CronIndexer.KEY]: CronIndexData;
 };
 
 class IndexManager {
+  private static readonly INDEX_BATCH_SIZE = 50;
+
   protected indexers: IndexerInstance[] = [];
   protected indexStorage: IndexStorage;
 
@@ -48,6 +54,7 @@ class IndexManager {
       new EventsIndexer(),
       new AclIndexer(),
       new TemplateIndexer(),
+      new CronIndexer(),
     ];
     this.indexStorage = new IndexStorage();
   }
@@ -86,23 +93,27 @@ class IndexManager {
       let doneCount = 0;
       const totalCount = files.length;
 
-      await Promise.all(
-        files.map(async file => {
-          const data = await indexer.indexFile(file);
+      for (let i = 0; i < files.length; i += IndexManager.INDEX_BATCH_SIZE) {
+        const batch = files.slice(i, i + IndexManager.INDEX_BATCH_SIZE);
+
+        await Promise.all(
+          batch.map(async file => {
+            const data = await indexer.indexFile(file);
 
-          if (data !== undefined) {
-            indexData.set(file.fsPath, data);
-          }
+            if (data !== undefined) {
+              indexData.set(file.fsPath, data);
+            }
 
-          doneCount++;
-          const pct = Math.round((doneCount / totalCount) * 100);
+            doneCount++;
+            const pct = Math.round((doneCount / totalCount) * 100);
 
-          progress.report({
-            message: `Indexing - ${indexer.getName()} [${doneCount}/${totalCount}]`,
-            increment: pct,
-          });
-        })
-      );
+            progress.report({
+              message: `Indexing - ${indexer.getName()} [${doneCount}/${totalCount}]`,
+              increment: pct,
+            });
+          })
+        );
+      }
 
       this.indexStorage.set(workspaceFolder, indexer.getId(), indexData);
       this.indexStorage.saveIndex(workspaceFolder, indexer.getId(), indexer.getVersion());
@@ -181,6 +192,9 @@ class IndexManager {
       case TemplateIndexer.KEY:
         return new TemplateIndexData(data) as IndexerDataMap[T];
 
+      case CronIndexer.KEY:
+        return new CronIndexData(data) as IndexerDataMap[T];
+
       default:
         return undefined;
     }

src/hover/xml/CronHoverProvider.ts

@@ -1,17 +1,19 @@
 import * as vscode from 'vscode';
 import IndexManager from './IndexManager';
+import ExtensionState from 'common/ExtensionState';
+import Common from 'util/Common';
 
 class IndexRunner {
   public async indexWorkspace(force: boolean = false): Promise<void> {
-    if (!vscode.workspace.workspaceFolders) {
+    if (ExtensionState.magentoWorkspaces.length === 0) {
       return;
     }
 
-    for (const workspaceFolder of vscode.workspace.workspaceFolders) {
+    for (const workspaceFolder of ExtensionState.magentoWorkspaces) {
       await vscode.window.withProgress(
         {
           location: vscode.ProgressLocation.Window,
-          title: '[Magento Toolbox]',
+          title: `Magento Toolbox v${Common.getVersion()}`,
         },
         async progress => {
           await IndexManager.indexWorkspace(workspaceFolder, progress, force);

src/indexer/IndexManager.ts

@@ -0,0 +1,25 @@
+import { Memoize } from 'typescript-memoize';
+import { Job } from './types';
+import { AbstractIndexData } from 'indexer/AbstractIndexData';
+import CronIndexer from './CronIndexer';
+
+export class CronIndexData extends AbstractIndexData<Job[]> {
+  @Memoize({
+    tags: [CronIndexer.KEY],
+  })
+  public getJobs(): Job[] {
+    return this.getValues().flatMap(data => data);
+  }
+
+  public findJobByName(group: string, name: string): Job | undefined {
+    return this.getJobs().find(job => job.group === group && job.name === name);
+  }
+
+  public findJobsByGroup(group: string): Job[] {
+    return this.getJobs().filter(job => job.group === group);
+  }
+
+  public findJobsByInstance(instance: string): Job[] {
+    return this.getJobs().filter(job => job.instance === instance);
+  }
+}