Add code folding based on heading level

.vscode/launch.json

@@ -24,6 +24,7 @@
       "request": "launch",
       "runtimeExecutable": "${execPath}",
       "args": [
+        "--disable-extensions",
         "--extensionDevelopmentPath=${workspaceFolder}",
         "--extensionTestsPath=${workspaceFolder}/dist/src/test/suite"
       ],

src/asciidocEngine.ts

@@ -7,6 +7,7 @@ import { AsciidocContributions } from './asciidocExtensions'
 import { Slugifier } from './slugify'
 import { AsciidocParser } from './asciidocParser'
 import { Asciidoctor } from '@asciidoctor/core'
+import { SkinnyTextDocument } from './util/document'
 
 const FrontMatterRegex = /^---\s*[^]*?(-{3}|\.{3})\s*/
 
@@ -64,9 +65,8 @@ export class AsciidocEngine {
     return { output, document }
   }
 
-  public async load (documentUri: vscode.Uri, source: string): Promise<any> {
-    const textDocument = await vscode.workspace.openTextDocument(documentUri)
-    const { document } = await this.getEngine().parseText(source, textDocument)
+  public async load (textDocument: SkinnyTextDocument): Promise<any> {
+    const { document } = await this.getEngine().parseText(textDocument.getText(), textDocument)
     return document
   }
 }

src/asciidocParser.ts

@@ -53,7 +53,7 @@ export class AsciidocParser {
 
   public convertUsingJavascript (
     text: string,
-    doc: vscode.TextDocument,
+    doc: SkinnyTextDocument,
     forHTMLSave: boolean,
     backend: string,
     context?: vscode.ExtensionContext,
@@ -176,7 +176,7 @@ export class AsciidocParser {
 
   public async parseText (
     text: string,
-    doc: vscode.TextDocument,
+    doc: SkinnyTextDocument,
     forHTMLSave: boolean = false,
     backend: string = 'webview-html5',
     context?: vscode.ExtensionContext,
@@ -185,7 +185,7 @@ export class AsciidocParser {
     return this.convertUsingJavascript(text, doc, forHTMLSave, backend, context, editor)
   }
 
-  private reportErrors (memoryLogger: Asciidoctor.MemoryLogger, textDocument: vscode.TextDocument) {
+  private reportErrors (memoryLogger: Asciidoctor.MemoryLogger, textDocument: SkinnyTextDocument) {
     const diagnostics = []
     memoryLogger.getMessages().forEach((error) => {
       //console.log(error); //Error from asciidoctor.js

src/extension.ts

@@ -18,6 +18,7 @@ import { githubSlugifier } from './slugify'
 import { AsciidocFileIncludeAutoCompletionMonitor } from './util/includeAutoCompletion'
 import { AttributeReferenceProvider } from './features/attributeReferenceProvider'
 import { BuiltinDocumentAttributeProvider } from './features/builtinDocumentAttributeProvider'
+import AsciidocFoldingRangeProvider from './features/foldingProvider'
 
 export function activate (context: vscode.ExtensionContext) {
   const contributions = getAsciidocExtensionContributions(context)
@@ -47,8 +48,8 @@ export function activate (context: vscode.ExtensionContext) {
   context.subscriptions.push(vscode.languages.registerWorkspaceSymbolProvider(new AsciidocWorkspaceSymbolProvider(symbolProvider)))
   context.subscriptions.push(vscode.languages.registerCompletionItemProvider(selector, new AttributeReferenceProvider(contributions.extensionUri), '{'))
   context.subscriptions.push(vscode.languages.registerCompletionItemProvider(selector, new BuiltinDocumentAttributeProvider(contributions.extensionUri), ':'))
+  context.subscriptions.push(vscode.languages.registerFoldingRangeProvider(selector, new AsciidocFoldingRangeProvider(engine)))
   const previewSecuritySelector = new PreviewSecuritySelector(cspArbiter, previewManager)
-
   const commandManager = new CommandManager()
   context.subscriptions.push(commandManager)
   commandManager.register(new commands.ShowPreviewCommand(previewManager))

src/features/foldingProvider.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+  *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode'
+
+import { AsciidocEngine } from '../asciidocEngine'
+import { TableOfContentsProvider } from '../tableOfContentsProvider'
+
+export default class AsciidocFoldingRangeProvider implements vscode.FoldingRangeProvider {
+  constructor (
+    private readonly engine: AsciidocEngine
+  ) {
+  }
+
+  public async provideFoldingRanges (
+    document: vscode.TextDocument,
+    _token: vscode.CancellationToken
+  ): Promise<vscode.FoldingRange[]> {
+    const tableOfContentsProvider = new TableOfContentsProvider(this.engine, document)
+    const tableOfContents = await tableOfContentsProvider.getToc()
+
+    return tableOfContents.map((entry, startIndex) => {
+      const start = entry.line
+      let end: number | undefined
+      for (let i = startIndex + 1; i < tableOfContents.length; ++i) {
+        if (tableOfContents[i].level <= entry.level) {
+          end = tableOfContents[i].line - 1
+          break
+        }
+      }
+      return new vscode.FoldingRange(
+        start,
+        typeof end === 'number' ? end : document.lineCount - 1)
+    })
+  }
+}

src/tableOfContentsProvider.ts

@@ -28,6 +28,7 @@ export class TableOfContentsProvider {
       try {
         this.toc = await this.buildToc(this.document)
       } catch (e) {
+        console.log(e)
         this.toc = []
       }
     }
@@ -42,7 +43,7 @@ export class TableOfContentsProvider {
 
   private async buildToc (document: SkinnyTextDocument): Promise<TocEntry[]> {
     const toc: TocEntry[] = []
-    const adoc = await this.engine.load(document.uri, document.getText())
+    const adoc = await this.engine.load(document)
 
     adoc.findBy({ context: 'section' }, function (section) {
       toc.push({

src/test/documentSymbolProvider.test.ts

@@ -9,7 +9,7 @@ import SymbolProvider from '../features/documentSymbolProvider'
 import { InMemoryDocument } from './inMemoryDocument'
 import { createNewAsciidocEngine } from './engine'
 
-const testFileName = vscode.Uri.file('test.md')
+const testFileName = vscode.Uri.file('test.adoc')
 
 function getSymbolsForFile (fileContents: string) {
   const doc = new InMemoryDocument(testFileName, fileContents)

src/test/foldingProvider.test.ts

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert'
+import 'mocha'
+import * as vscode from 'vscode'
+import AsciidocFoldingProvider from '../features/foldingProvider'
+import { createNewAsciidocEngine } from './engine'
+import { InMemoryDocument } from './inMemoryDocument'
+
+const testFileName = vscode.Uri.file('test.adoc')
+
+suite('asciidoc.FoldingProvider', () => {
+  test('Should not return anything for empty document', async () => {
+    const folds = await getFoldsForDocument('')
+    assert.strictEqual(folds.length, 0)
+  })
+
+  test('Should not return anything for document without headers', async () => {
+    const folds = await getFoldsForDocument(`a
+*b* afas
+a=b
+a`)
+    assert.strictEqual(folds.length, 0)
+  })
+
+  test('Should fold from header to end of document', async () => {
+    const folds = await getFoldsForDocument(`= a
+
+== b
+
+c
+d`)
+    assert.strictEqual(folds.length, 2)
+    const firstFold = folds[0]
+    assert.strictEqual(firstFold.start, 0)
+    assert.strictEqual(firstFold.end, 5)
+  })
+
+  test('Should leave single newline before next header', async () => {
+    const folds = await getFoldsForDocument(`
+== a
+x
+
+== b
+y`)
+    assert.strictEqual(folds.length, 2)
+    const firstFold = folds[0]
+    assert.strictEqual(firstFold.start, 1)
+    assert.strictEqual(firstFold.end, 3)
+  })
+
+  test('Should collapse multiple newlines to single newline before next header', async () => {
+    const folds = await getFoldsForDocument(`
+= a
+x
+
+
+
+= b
+y`)
+    assert.strictEqual(folds.length, 2)
+    const firstFold = folds[0]
+    assert.strictEqual(firstFold.start, 1)
+    assert.strictEqual(firstFold.end, 5)
+  })
+
+  test('Should not collapse if there is no newline before next header', async () => {
+    const folds = await getFoldsForDocument(`
+= a
+x
+== b
+y`)
+    assert.strictEqual(folds.length, 1)
+    const firstFold = folds[0]
+    assert.strictEqual(firstFold.start, 1)
+    assert.strictEqual(firstFold.end, 4)
+  })
+})
+
+async function getFoldsForDocument (contents: string) {
+  const doc = new InMemoryDocument(testFileName, contents)
+  const provider = new AsciidocFoldingProvider(createNewAsciidocEngine())
+  return await provider.provideFoldingRanges(doc, new vscode.CancellationTokenSource().token)
+}