feat: theme definitions and hovers

Author: raideer

package.json

@@ -67,6 +67,11 @@
           "type": "boolean",
           "default": true,
           "description": "Enable hover decorations for Magento 2 XML files."
+        },
+        "magento-toolbox.provideThemeDefinitions": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable definitions for Magento 2 theme files."
         }
       }
     },

src/definition/XmlDefinitionProviderProcessor.ts

@@ -9,6 +9,7 @@ import { XmlSuggestionProviderProcessor } from 'common/xml/XmlSuggestionProvider
 import { AclDefinitionProvider } from './xml/AclDefinitionProvider';
 import { ModuleDefinitionProvider } from './xml/ModuleDefinitionProvider';
 import { TemplateDefinitionProvider } from './xml/TemplateDefinitionProvider';
+import { ThemeDefinitionProvider } from './xml/ThemeDefinitionProvider';
 
 export class XmlDefinitionProviderProcessor
   extends XmlSuggestionProviderProcessor<LocationLink>
@@ -19,6 +20,7 @@ export class XmlDefinitionProviderProcessor
       new AclDefinitionProvider(),
       new ModuleDefinitionProvider(),
       new TemplateDefinitionProvider(),
+      new ThemeDefinitionProvider(),
     ]);
   }
 

src/definition/xml/ThemeDefinitionProvider.ts

@@ -0,0 +1,48 @@
+import { LocationLink, Uri, Range, TextDocument } from 'vscode';
+import IndexManager from 'indexer/IndexManager';
+import { XmlSuggestionProvider, CombinedCondition } from 'common/xml/XmlSuggestionProvider';
+import { XMLElement, XMLAttribute } from '@xml-tools/ast';
+import { ElementNameMatches } from 'common/xml/suggestion/condition/ElementNameMatches';
+import ThemeIndexer from 'indexer/theme/ThemeIndexer';
+
+export class ThemeDefinitionProvider extends XmlSuggestionProvider<LocationLink> {
+  public getFilePatterns(): string[] {
+    return ['**/theme.xml'];
+  }
+
+  public getElementContentMatches(): CombinedCondition[] {
+    return [[new ElementNameMatches('parent')]];
+  }
+
+  public getConfigKey(): string | undefined {
+    return 'provideThemeDefinitions';
+  }
+
+  public getSuggestionItems(
+    value: string,
+    range: Range,
+    document: TextDocument,
+    element: XMLElement,
+    attribute?: XMLAttribute
+  ): LocationLink[] {
+    const themeIndexData = IndexManager.getIndexData(ThemeIndexer.KEY);
+
+    if (!themeIndexData) {
+      return [];
+    }
+
+    const theme = themeIndexData.getThemeById(value);
+
+    if (!theme) {
+      return [];
+    }
+
+    return [
+      {
+        targetUri: Uri.file(theme.path),
+        targetRange: new Range(0, 0, 0, 0),
+        originSelectionRange: range,
+      },
+    ];
+  }
+}

src/hover/XmlHoverProviderProcessor.ts

@@ -3,10 +3,16 @@ import { XmlSuggestionProviderProcessor } from 'common/xml/XmlSuggestionProvider
 import { AclHoverProvider } from 'hover/xml/AclHoverProvider';
 import { ModuleHoverProvider } from 'hover/xml/ModuleHoverProvider';
 import { CronHoverProvider } from 'hover/xml/CronHoverProvider';
+import { ThemeHoverProvider } from 'hover/xml/ThemeHoverProvider';
 
 export class XmlHoverProviderProcessor extends XmlSuggestionProviderProcessor<Hover> {
   public constructor() {
-    super([new AclHoverProvider(), new ModuleHoverProvider(), new CronHoverProvider()]);
+    super([
+      new AclHoverProvider(),
+      new ModuleHoverProvider(),
+      new CronHoverProvider(),
+      new ThemeHoverProvider(),
+    ]);
   }
 
   public async provideHover(

src/hover/xml/ThemeHoverProvider.ts

@@ -0,0 +1,63 @@
+import { Hover, MarkdownString, Uri, Range, workspace, TextDocument } from 'vscode';
+import IndexManager from 'indexer/IndexManager';
+import { CombinedCondition, XmlSuggestionProvider } from 'common/xml/XmlSuggestionProvider';
+import { ElementNameMatches } from 'common/xml/suggestion/condition/ElementNameMatches';
+import { XMLElement, XMLAttribute } from '@xml-tools/ast';
+import ThemeIndexer from 'indexer/theme/ThemeIndexer';
+import path from 'path';
+
+export class ThemeHoverProvider extends XmlSuggestionProvider<Hover> {
+  public getElementContentMatches(): CombinedCondition[] {
+    return [[new ElementNameMatches('parent')]];
+  }
+
+  public getConfigKey(): string | undefined {
+    return 'provideXmlHovers';
+  }
+
+  public getFilePatterns(): string[] {
+    return ['**/theme.xml'];
+  }
+
+  public getSuggestionItems(
+    value: string,
+    range: Range,
+    document: TextDocument,
+    element: XMLElement,
+    attribute?: XMLAttribute
+  ): Hover[] {
+    const workspaceFolder = workspace.getWorkspaceFolder(document.uri);
+
+    if (!workspaceFolder) {
+      return [];
+    }
+
+    const themeIndexData = IndexManager.getIndexData(ThemeIndexer.KEY);
+
+    if (!themeIndexData) {
+      return [];
+    }
+
+    const theme = themeIndexData.getThemeById(value);
+
+    if (!theme) {
+      return [];
+    }
+
+    const markdown = new MarkdownString();
+    markdown.appendMarkdown(`**Theme**: ${theme.title}\n\n`);
+    markdown.appendMarkdown(`- ID: \`${theme.id}\`\n\n`);
+
+    const relativePath = path.relative(workspaceFolder.uri.fsPath, theme.path);
+
+    markdown.appendMarkdown(`- Path: \`${relativePath}\`\n\n`);
+
+    if (theme.parent) {
+      markdown.appendMarkdown(`- Parent: \n\n    - ${theme.parent}\n\n`);
+    }
+
+    markdown.appendMarkdown(`[theme.xml](${Uri.file(theme.path)})`);
+
+    return [new Hover(markdown, range)];
+  }
+}

src/indexer/IndexManager.ts

@@ -116,6 +116,10 @@ class IndexManager {
 
         await Promise.all(
           batch.map(async file => {
+            if (!indexer.canIndex(file)) {
+              return;
+            }
+
             const data = await indexer.indexFile(file);
 
             if (data !== undefined) {

src/indexer/Indexer.ts

@@ -5,6 +5,9 @@ export abstract class Indexer<D = any> {
   public abstract getId(): IndexerKey;
   public abstract getName(): string;
   public abstract getPattern(uri: Uri): GlobPattern;
+  public canIndex(uri: Uri): boolean {
+    return true;
+  }
   public abstract indexFile(uri: Uri): Promise<D | undefined>;
   public abstract getVersion(): number;
 }

src/indexer/theme/ThemeIndexData.ts

@@ -17,4 +17,8 @@ export class ThemeIndexData extends AbstractIndexData<Theme> {
       return normalized.startsWith(base);
     });
   }
+
+  public getThemeById(id: string): Theme | undefined {
+    return this.getThemes().find(theme => theme.id.toLowerCase() === id.toLowerCase());
+  }
 }

src/indexer/theme/ThemeIndexer.ts

@@ -36,7 +36,17 @@ export default class ThemeIndexer extends Indexer<Theme> {
     return new RelativePattern(uri, '**/theme.xml');
   }
 
+  public canIndex(uri: Uri): boolean {
+    return !uri.fsPath.includes('Test/Unit') && !uri.fsPath.includes('dev/tests');
+  }
+
   public async indexFile(uri: Uri): Promise<Theme | undefined> {
+    const id = await this.getThemeId(uri);
+
+    if (!id) {
+      return undefined;
+    }
+
     const xml = await FileSystem.readFile(uri);
     const parsed = this.xmlParser.parse(xml);
 
@@ -52,11 +62,31 @@ export default class ThemeIndexer extends Indexer<Theme> {
 
     const theme: Theme = {
       title,
+      id,
       path: uri.fsPath,
       basePath: Uri.joinPath(uri, '..').fsPath,
       parent: typeof parent === 'string' ? parent : undefined,
     };
 
     return theme;
   }
+
+  private async getThemeId(uri: Uri): Promise<string | undefined> {
+    const registrationUri = Uri.joinPath(uri, '../registration.php');
+
+    let registration: string | undefined;
+    try {
+      registration = await FileSystem.readFile(registrationUri);
+    } catch (error) {
+      return undefined;
+    }
+
+    const themeId = registration.match(/'frontend\/(.+)'/);
+
+    if (!themeId) {
+      return undefined;
+    }
+
+    return themeId[1];
+  }
 }

src/indexer/theme/types.ts

@@ -1,5 +1,6 @@
 export interface Theme {
   title: string;
+  id: string;
   path: string;
   basePath: string;
   parent?: string;