Merge pull request #54 from schultyy/feature/better-header-errors

Feature/better header errors

Author: Jan Schulte

package.json

@@ -13,7 +13,7 @@
         "type": "git",
         "url": "https://github.com/schultyy/better-seo"
     },
-    "version": "1.6.0",
+    "version": "1.7.0",
     "icon": "resources/better_seo.png",
     "engines": {
         "vscode": "^1.54.0"

src/analyzer.ts

@@ -36,6 +36,16 @@ export class ParagraphError extends AnalyzerError {
     }
 }
 
+export class HeaderError extends AnalyzerError {
+    constructor(
+        public title: string,
+        public loc: Location,
+        public message: string,
+        public resultType: ResultType) {
+            super(title, message, resultType);
+        }
+}
+
 interface AstChild {
     type: string;
     value: string;
@@ -93,10 +103,15 @@ export class FileAnalyzer {
     }
 
     private validateHeaderStructure() : Array<AnalyzerResult> {
-        if(this.children.filter(child => child.type === 'Header' && child.depth === 1).length > 1) {
-            return [
-                new AnalyzerError('Header', 'Inconsistent Header Structure. Only one first level Header allowed.', ResultType.body)
-            ];
+        const firstLevelHeadlines = this.children.filter(child => child.type === 'Header' && child.depth === 1);
+        if(firstLevelHeadlines.length > 1) {
+            return firstLevelHeadlines.map(firstLevelHeadline => {
+                return new HeaderError(
+                        'Header',
+                        firstLevelHeadline.loc,
+                        'Inconsistent Header Structure. Only one first level Header allowed.',
+                        ResultType.body);
+            });
         }
         return [];
     }

src/extension.ts

@@ -1,21 +1,47 @@
 // The module 'vscode' contains the VS Code extensibility API
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
-import TreeProvider from './treeProvider';
+import TreeProvider, { FindingWithPosition } from './treeProvider';
+
+function moveCursor(firstSelection: FindingWithPosition) {
+    const editor = vscode.window.activeTextEditor;
+    if(!editor) {
+        return;
+    }
+    const position = editor.selection.active;
+
+    const startLine = firstSelection.location.start.line === 0 ? 0 : firstSelection.location.start.line - 1;
+    const newPosition = position.with(startLine, firstSelection.location.start.column);
+    const newSelection = new vscode.Selection(newPosition, newPosition);
+    editor.selection = newSelection;
+}
 
 // this method is called when your extension is activated
 // your extension is activated the very first time the command is executed
 export function activate(context: vscode.ExtensionContext) {
 
-	// Use the console to output diagnostic information (console.log) and errors (console.error)
-	// This line of code will only be executed once when your extension is activated
-	const seoResultTreeProvider = new TreeProvider();
-	vscode.window.registerTreeDataProvider('seo-results', seoResultTreeProvider);
+    // Use the console to output diagnostic information (console.log) and errors (console.error)
+    // This line of code will only be executed once when your extension is activated
+    const seoResultTreeProvider = new TreeProvider();
+    const treeView = vscode.window.createTreeView('seo-results', {
+        treeDataProvider: seoResultTreeProvider
+    });
+
+    treeView.onDidChangeSelection((event) => {
+        console.log(event instanceof FindingWithPosition);
+        if(event.selection.length === 0) {
+            return;
+        }
+        const firstSelection = event.selection[0];
+        if(firstSelection instanceof FindingWithPosition) {
+            moveCursor(firstSelection);
+        }
+    });
 
-	let disposable = vscode.commands.registerCommand('better-seo.refresh', () => {
-		seoResultTreeProvider.refresh();
-	});
-	context.subscriptions.push(disposable);
+    let disposable = vscode.commands.registerCommand('better-seo.refresh', () => {
+        seoResultTreeProvider.refresh();
+    });
+    context.subscriptions.push(disposable);
 }
 
 // this method is called when your extension is deactivated

src/test/suite/extension.test.ts

@@ -310,10 +310,10 @@ suite('Extension Test Suite', () => {
                 assert.ok(headerError === null || headerError === undefined);
             });
 
-            test('Only returns one Header error even for multiple keywords', () => {
+            test('Returns one Header error for each first-level headline', () => {
                 const results = runAnalysis(withIncorrectHeadersMultipleKeywords, frontmatterConfiguration);
-                const headerError = results.filter(result => result.title === 'Header');
-                assert.strictEqual(headerError.length, 1);
+                const headerError = results.filter(result => result.title === 'Header' && result.message.startsWith('Inconsistent Header Structure.'));
+                assert.strictEqual(headerError.length, 2);
             });
         });
 

src/treeProvider.ts

@@ -1,5 +1,5 @@
 import { Event, EventEmitter, Position, ProviderResult, TreeDataProvider, TreeItem, TreeItemCollapsibleState, window, workspace } from "vscode";
-import { AnalyzerError, AnalyzerResult, Location, ParagraphError, ResultType, runAnalysis } from "./analyzer";
+import { AnalyzerError, AnalyzerResult, HeaderError, Location, ParagraphError, ResultType, runAnalysis } from "./analyzer";
 import * as path from 'path';
 
 export default class TreeProvider implements TreeDataProvider<ResultsTreeItem> {
@@ -41,11 +41,42 @@ export default class TreeProvider implements TreeDataProvider<ResultsTreeItem> {
                 this.generateParagraphErrors(<ParagraphFinding> element)
             );
         }
+        else if(element.label === 'Header') {
+            return Promise.resolve(
+                this.generateHeaderErrors(<HeaderFinding> element)
+            )
+        }
         else {
             return Promise.resolve([]);
         }
     }
 
+    generateHeaderErrors(element: HeaderFinding): FindingWithPosition[] {
+        const startLocationToString = (loc: Location) => (
+            `Line:Column ${element.header.loc.start.line}:${element.header.loc.start.column}`
+        );
+        const endLocationToString = (loc: Location) => (
+            `Line:Column ${element.header.loc.end.line}:${element.header.loc.end.column}`
+        );
+
+        return [
+            new FindingWithPosition(
+                "Start",
+                startLocationToString(element.header.loc),
+                element.header.loc,
+                this,
+                TreeItemCollapsibleState.None
+            ),
+            new FindingWithPosition(
+                "End",
+                endLocationToString(element.header.loc),
+                element.header.loc,
+                this,
+                TreeItemCollapsibleState.None
+            )
+        ];
+    }
+
     generateParagraphErrors(element: ParagraphFinding): FindingWithPosition[] {
 
         const startLocationToString = (loc: Location) => (
@@ -82,7 +113,11 @@ export default class TreeProvider implements TreeDataProvider<ResultsTreeItem> {
     private generateBodyError(result: AnalyzerResult): Finding {
         if (result instanceof ParagraphError) {
             return new ParagraphFinding(result.title, result.message, result, this, TreeItemCollapsibleState.Collapsed);
-        } else {
+        }
+        else if (result instanceof HeaderError) {
+            return new HeaderFinding(result.title, result.message, result, this, TreeItemCollapsibleState.Collapsed);
+        }
+        else {
             return new Finding(result.title, result.message, this, TreeItemCollapsibleState.None);
         }
     }
@@ -154,6 +189,18 @@ export class Finding extends ResultsTreeItem {
     };
 }
 
+export class HeaderFinding extends Finding {
+    constructor(
+        public readonly label: string,
+        public readonly description: string,
+        public readonly header: HeaderError,
+        public provider: TreeProvider,
+        public readonly collapsibleState: TreeItemCollapsibleState
+        ) {
+            super(label, description, provider, collapsibleState);
+        }
+}
+
 export class ParagraphFinding extends Finding {
     constructor(
         public readonly label: string,